Résolution de problèmes parallèles embarrassants en utilisant Python multiprocessing
Comment utilise-t-on multiprocessing pour s'attaquer problèmes parallèlement embarrassants ?
Les problèmes parallèlement embarrassants se composent généralement de trois parties fondamentales:
- Lire les données d'entrée (à partir d'un fichier, d'une base de données, d'une connexion TCP, etc.).
- Exécutez des calculs sur les données d'entrée, où chaque calcul est indépendant de tout autre calcul.
- Ecrire les résultats des calculs (dans un fichier, une base de données, une connexion TCP, etc.).
Nous pouvons paralléliser le programme en deux dimensions:
- La partie 2 peut fonctionner sur plusieurs cœurs, car chaque calcul est indépendant; l'ordre de traitement n'a pas d'importance.
- Chaque partie peut fonctionner indépendamment. La partie 1 peut placer des données dans une file d'attente d'entrée, la partie 2 peut extraire des données de la file d'attente d'entrée et placer les résultats dans une file d'attente de sortie, et la partie 3 peut extraire les résultats de la file d'attente de sortie et les écrire.
Cela semble être le modèle le plus élémentaire de la programmation simultanée, mais je suis toujours perdu à essayer de le résoudre, alors écrivons un exemple canonique pour illustrer comment cela se fait en utilisant le multitraitement .
Voici l'exemple de problème: Étant donné un fichier CSV avec des lignes d'entiers en entrée, calculez leurs sommes. Séparez le problème en trois parties, qui peuvent toutes s'exécuter en parallèle:
- Traiter le fichier d'entrée en données brutes (listes/itérables d'entiers)
- Calculer les sommes des données, en parallèle
- Sortie des sommes
Ci-dessous est un programme traditionnel, lié à un seul processus Python qui résout ces trois tâches:
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# basicsums.py
"""A program that reads integer values from a CSV file and writes out their
sums to another CSV file.
"""
import csv
import optparse
import sys
def make_cli_parser():
"""Make the command line interface parser."""
usage = "\n\n".join(["python %prog INPUT_CSV OUTPUT_CSV",
__doc__,
"""
ARGUMENTS:
INPUT_CSV: an input CSV file with rows of numbers
OUTPUT_CSV: an output file that will contain the sums\
"""])
cli_parser = optparse.OptionParser(usage)
return cli_parser
def parse_input_csv(csvfile):
"""Parses the input CSV and yields tuples with the index of the row
as the first element, and the integers of the row as the second
element.
The index is zero-index based.
:Parameters:
- `csvfile`: a `csv.reader` instance
"""
for i, row in enumerate(csvfile):
row = [int(entry) for entry in row]
yield i, row
def sum_rows(rows):
"""Yields a Tuple with the index of each input list of integers
as the first element, and the sum of the list of integers as the
second element.
The index is zero-index based.
:Parameters:
- `rows`: an iterable of tuples, with the index of the original row
as the first element, and a list of integers as the second element
"""
for i, row in rows:
yield i, sum(row)
def write_results(csvfile, results):
"""Writes a series of results to an outfile, where the first column
is the index of the original row of data, and the second column is
the result of the calculation.
The index is zero-index based.
:Parameters:
- `csvfile`: a `csv.writer` instance to which to write results
- `results`: an iterable of tuples, with the index (zero-based) of
the original row as the first element, and the calculated result
from that row as the second element
"""
for result_row in results:
csvfile.writerow(result_row)
def main(argv):
cli_parser = make_cli_parser()
opts, args = cli_parser.parse_args(argv)
if len(args) != 2:
cli_parser.error("Please provide an input file and output file.")
infile = open(args[0])
in_csvfile = csv.reader(infile)
outfile = open(args[1], 'w')
out_csvfile = csv.writer(outfile)
# gets an iterable of rows that's not yet evaluated
input_rows = parse_input_csv(in_csvfile)
# sends the rows iterable to sum_rows() for results iterable, but
# still not evaluated
result_rows = sum_rows(input_rows)
# finally evaluation takes place as a chain in write_results()
write_results(out_csvfile, result_rows)
infile.close()
outfile.close()
if __name__ == '__main__':
main(sys.argv[1:])
Prenons ce programme et réécrivons-le pour utiliser le multitraitement afin de paralléliser les trois parties décrites ci-dessus. Voici un squelette de ce nouveau programme parallélisé, qui doit être étoffé pour aborder les parties dans les commentaires:
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# multiproc_sums.py
"""A program that reads integer values from a CSV file and writes out their
sums to another CSV file, using multiple processes if desired.
"""
import csv
import multiprocessing
import optparse
import sys
NUM_PROCS = multiprocessing.cpu_count()
def make_cli_parser():
"""Make the command line interface parser."""
usage = "\n\n".join(["python %prog INPUT_CSV OUTPUT_CSV",
__doc__,
"""
ARGUMENTS:
INPUT_CSV: an input CSV file with rows of numbers
OUTPUT_CSV: an output file that will contain the sums\
"""])
cli_parser = optparse.OptionParser(usage)
cli_parser.add_option('-n', '--numprocs', type='int',
default=NUM_PROCS,
help="Number of processes to launch [DEFAULT: %default]")
return cli_parser
def main(argv):
cli_parser = make_cli_parser()
opts, args = cli_parser.parse_args(argv)
if len(args) != 2:
cli_parser.error("Please provide an input file and output file.")
infile = open(args[0])
in_csvfile = csv.reader(infile)
outfile = open(args[1], 'w')
out_csvfile = csv.writer(outfile)
# Parse the input file and add the parsed data to a queue for
# processing, possibly chunking to decrease communication between
# processes.
# Process the parsed data as soon as any (chunks) appear on the
# queue, using as many processes as allotted by the user
# (opts.numprocs); place results on a queue for output.
#
# Terminate processes when the parser stops putting data in the
# input queue.
# Write the results to disk as soon as they appear on the output
# queue.
# Ensure all child processes have terminated.
# Clean up files.
infile.close()
outfile.close()
if __name__ == '__main__':
main(sys.argv[1:])
Ces morceaux de code, ainsi que n autre morceau de code qui peut générer des exemples de fichiers CSV à des fins de test, peuvent être trouvés sur github .
J'apprécierais tout aperçu ici sur la façon dont vos gourous de la concurrence aborderaient ce problème.
Voici quelques questions que j'ai eues en pensant à ce problème. Points bonus pour aborder tout/tout:
- Dois-je avoir des processus enfants pour lire les données et les placer dans la file d'attente, ou le processus principal peut-il le faire sans bloquer jusqu'à ce que toutes les entrées soient lues?
- De même, dois-je avoir un processus enfant pour écrire les résultats à partir de la file d'attente traitée, ou le processus principal peut-il le faire sans avoir à attendre tous les résultats?
- Dois-je utiliser un pool de processus pour les opérations de somme?
- Si oui, quelle méthode dois-je appeler sur le pool pour qu'il commence à traiter les résultats entrant dans la file d'attente d'entrée, sans bloquer les processus d'entrée et de sortie également? apply_async () ? map_async () ? imap () ? imap_unordered () ?
- Supposons que nous n'ayons pas besoin de siphonner les files d'attente d'entrée et de sortie au fur et à mesure que les données les ont saisies, mais pouvons attendre que toutes les entrées soient analysées et que tous les résultats soient calculés (par exemple, car nous savons que toutes les entrées et sorties entreront dans la mémoire système). Devrions-nous modifier l'algorithme de quelque manière que ce soit (par exemple, ne pas exécuter de processus simultanément avec les E/S)?
Ma solution a une cloche et un sifflet supplémentaires pour s'assurer que l'ordre de la sortie a le même que l'ordre de l'entrée. J'utilise multiprocessing.queue pour envoyer des données entre les processus, en envoyant des messages d'arrêt afin que chaque processus sache arrêter de vérifier les files d'attente. Je pense que les commentaires dans la source devraient clarifier ce qui se passe mais sinon faites le moi savoir.
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# multiproc_sums.py
"""A program that reads integer values from a CSV file and writes out their
sums to another CSV file, using multiple processes if desired.
"""
import csv
import multiprocessing
import optparse
import sys
NUM_PROCS = multiprocessing.cpu_count()
def make_cli_parser():
"""Make the command line interface parser."""
usage = "\n\n".join(["python %prog INPUT_CSV OUTPUT_CSV",
__doc__,
"""
ARGUMENTS:
INPUT_CSV: an input CSV file with rows of numbers
OUTPUT_CSV: an output file that will contain the sums\
"""])
cli_parser = optparse.OptionParser(usage)
cli_parser.add_option('-n', '--numprocs', type='int',
default=NUM_PROCS,
help="Number of processes to launch [DEFAULT: %default]")
return cli_parser
class CSVWorker(object):
def __init__(self, numprocs, infile, outfile):
self.numprocs = numprocs
self.infile = open(infile)
self.outfile = outfile
self.in_csvfile = csv.reader(self.infile)
self.inq = multiprocessing.Queue()
self.outq = multiprocessing.Queue()
self.pin = multiprocessing.Process(target=self.parse_input_csv, args=())
self.pout = multiprocessing.Process(target=self.write_output_csv, args=())
self.ps = [ multiprocessing.Process(target=self.sum_row, args=())
for i in range(self.numprocs)]
self.pin.start()
self.pout.start()
for p in self.ps:
p.start()
self.pin.join()
i = 0
for p in self.ps:
p.join()
print "Done", i
i += 1
self.pout.join()
self.infile.close()
def parse_input_csv(self):
"""Parses the input CSV and yields tuples with the index of the row
as the first element, and the integers of the row as the second
element.
The index is zero-index based.
The data is then sent over inqueue for the workers to do their
thing. At the end the input process sends a 'STOP' message for each
worker.
"""
for i, row in enumerate(self.in_csvfile):
row = [ int(entry) for entry in row ]
self.inq.put( (i, row) )
for i in range(self.numprocs):
self.inq.put("STOP")
def sum_row(self):
"""
Workers. Consume inq and produce answers on outq
"""
tot = 0
for i, row in iter(self.inq.get, "STOP"):
self.outq.put( (i, sum(row)) )
self.outq.put("STOP")
def write_output_csv(self):
"""
Open outgoing csv file then start reading outq for answers
Since I chose to make sure output was synchronized to the input there
is some extra goodies to do that.
Obviously your input has the original row number so this is not
required.
"""
cur = 0
stop = 0
buffer = {}
# For some reason csv.writer works badly across processes so open/close
# and use it all in the same process or else you'll have the last
# several rows missing
outfile = open(self.outfile, "w")
self.out_csvfile = csv.writer(outfile)
#Keep running until we see numprocs STOP messages
for works in range(self.numprocs):
for i, val in iter(self.outq.get, "STOP"):
# verify rows are in order, if not save in buffer
if i != cur:
buffer[i] = val
else:
#if yes are write it out and make sure no waiting rows exist
self.out_csvfile.writerow( [i, val] )
cur += 1
while cur in buffer:
self.out_csvfile.writerow([ cur, buffer[cur] ])
del buffer[cur]
cur += 1
outfile.close()
def main(argv):
cli_parser = make_cli_parser()
opts, args = cli_parser.parse_args(argv)
if len(args) != 2:
cli_parser.error("Please provide an input file and output file.")
c = CSVWorker(opts.numprocs, args[0], args[1])
if __== '__main__':
main(sys.argv[1:])
Venir en retard à la fête ...
joblib a une couche au-dessus du multitraitement pour aider à faire des boucles parallèles. Il vous offre des fonctionnalités telles qu'une répartition paresseuse des tâches et un meilleur rapport d'erreurs en plus de sa syntaxe très simple.
Comme avertissement, je suis l'auteur original de joblib.
Je me rends compte que je suis un peu en retard pour la fête, mais j'ai récemment découvert parallèle GN , et je veux montrer à quel point il est facile d'accomplir cette tâche typique avec.
cat input.csv | parallel ./sum.py --pipe > sums
Quelque chose comme ça fera l'affaire pour sum.py:
#!/usr/bin/python
from sys import argv
if __== '__main__':
row = argv[-1]
values = (int(value) for value in row.split(','))
print row, ':', sum(values)
Le parallèle s'exécutera sum.py pour chaque ligne dans input.csv (en parallèle, bien sûr), puis affichez les résultats dans sums. Clairement mieux que multiprocessing tracas
Vieille école.
p1.py
import csv
import pickle
import sys
with open( "someFile", "rb" ) as source:
rdr = csv.reader( source )
for line in eumerate( rdr ):
pickle.dump( line, sys.stdout )
p2.py
import pickle
import sys
while True:
try:
i, row = pickle.load( sys.stdin )
except EOFError:
break
pickle.dump( i, sum(row) )
p3.py
import pickle
import sys
while True:
try:
i, row = pickle.load( sys.stdin )
except EOFError:
break
print i, row
Voici la structure finale multi-traitement.
python p1.py | python p2.py | python p3.py
Oui, le Shell les a assemblés au niveau du système d'exploitation. Cela me semble plus simple et cela fonctionne très bien.
Oui, l'utilisation des cornichons (ou cPickle) est légèrement supérieure. Cependant, la simplification semble valoir la peine.
Si vous voulez que le nom de fichier soit un argument pour p1.py, c'est un changement facile.
Plus important encore, une fonction comme la suivante est très pratique.
def get_stdin():
while True:
try:
yield pickle.load( sys.stdin )
except EOFError:
return
Cela vous permet de faire ceci:
for item in get_stdin():
process item
C'est très simple, mais cela ne permet pas facilement d'avoir plusieurs copies de P2.py en cours d'exécution.
Vous avez deux problèmes: fan-out et fan-in. Le P1.py doit en quelque sorte se déployer sur plusieurs P2.py. Et les P2.py doivent en quelque sorte fusionner leurs résultats en un seul P3.py.
L'approche old-school du fan-out est une architecture "Push", qui est très efficace.
Théoriquement, plusieurs P2.py tirant d'une file d'attente commune sont l'allocation optimale des ressources. C'est souvent idéal, mais c'est aussi une bonne quantité de programmation. La programmation est-elle vraiment nécessaire? Ou le traitement à tour de rôle sera-t-il assez bon?
En pratique, vous constaterez que faire P1.py faire un simple "round robin" traitant entre plusieurs P2.py peut être assez bon. Vous auriez P1.py configuré pour traiter n copies de P2.py via des canaux nommés. Les P2.py's liraient chacun à partir de leur pipe appropriée.
Que se passe-t-il si un P2.py obtient toutes les données du "pire des cas" et accuse un retard important? Oui, le tournoi à la ronde n'est pas parfait. Mais c'est mieux qu'un seul P2.py et vous pouvez corriger ce biais avec une simple randomisation.
Fan-in de plusieurs P2.py à un P3.py est encore un peu plus complexe. À ce stade, l'approche old-school cesse d'être avantageuse. P3.py doit lire à partir de plusieurs canaux nommés en utilisant la bibliothèque select pour entrelacer les lectures.
Il est probablement possible d'introduire un peu de parallélisme dans la partie 1 également. Ce n'est probablement pas un problème avec un format aussi simple que CSV, mais si le traitement des données d'entrée est sensiblement plus lent que la lecture des données, vous pouvez lire de plus gros morceaux, puis continuer à lire jusqu'à ce que vous trouviez un "séparateur de lignes" ( newline dans le cas CSV, mais encore une fois cela dépend du format lu; ne fonctionne pas si le format est suffisamment complexe).
Ces morceaux, chacun contenant probablement plusieurs entrées, peuvent ensuite être regroupés dans une foule de processus parallèles lisant des travaux dans une file d'attente, où ils sont analysés et divisés, puis placés dans la file d'attente pour l'étape 2.