Решение проблемных параллельных задач с использованием многопроцессорности Python

Ответ 1

Мое решение имеет дополнительный звонок и свист, чтобы убедиться, что порядок вывода имеет тот же порядок, что и порядок ввода. Я использую multiprocessing.queue для отправки данных между процессами, отправки стоп-сообщений, так что каждый процесс знает, чтобы завершить проверку очередей. Я думаю, что комментарии в источнике должны дать понять, что происходит, но если не сообщать мне.

#!/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 __name__ == '__main__':
    main(sys.argv[1:])

Ответ 2

Поздняя вечеринка...

joblib имеет слой поверх многопроцессорности, чтобы помочь создавать параллельные для циклов. Это дает вам возможности, такие как ленивая диспетчеризация рабочих мест, и лучшая отчетность об ошибках в дополнение к очень простому синтаксису.

Как отказ от ответственности, я являюсь оригинальным автором joblib.

Ответ 3

Я понимаю, что я немного опаздываю на вечеринку, но недавно я обнаружил GNU parallel и хочу показать, насколько легко он должен выполнить эту типичную задачу с ней.

cat input.csv | parallel ./sum.py --pipe > sums

Что-то вроде этого сделает для sum.py:

#!/usr/bin/python

from sys import argv

if __name__ == '__main__':
    row = argv[-1]
    values = (int(value) for value in row.split(','))
    print row, ':', sum(values)

Параллельно будет запускать sum.py для каждой строки в input.csv (параллельно, конечно), а затем выводить результаты на sums. Ясно лучше, чем multiprocessing hassle

Ответ 4

Старая школа.

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

Здесь представлена ​​окончательная структура многопроцессорной обработки.

python p1.py | python p2.py | python p3.py

Да, оболочка объединяет их вместе на уровне ОС. Мне кажется, что это проще для меня, и это работает очень хорошо.

Да, немного больше накладных расходов при использовании pickle (или cPickle). Однако упрощение, похоже, стоит усилий.

Если вы хотите, чтобы имя файла являлось аргументом p1.py, это легкое изменение.

Что еще более важно, очень удобна такая функция, как следующая.

def get_stdin():
    while True:
        try:
            yield pickle.load( sys.stdin )
        except EOFError:
            return

Это позволяет вам сделать это:

for item in get_stdin():
     process item

Это очень просто, но это не легко позволяет вам иметь несколько копий P2.py.

У вас две проблемы: вентилятор и вентилятор. P1.py должен каким-то образом развернуть несколько P2.py. И P2.py должен каким-то образом объединить свои результаты в один P3.py.

Подход старой школы к разветвлению - это "Push" архитектура, которая очень эффективна.

Теоретически, множественное P2.py, вытаскивающее из общей очереди, является оптимальным распределением ресурсов. Это часто идеально, но это также довольно много программирования. Действительно ли программирование действительно необходимо? Или будет ли обработка с круговой обработкой достаточно хорошей?

Практически вы обнаружите, что создание P1.py делает простой "круглый робин", который имеет дело с несколькими P2.py, может быть довольно хорошим. У вас будет P1.py, сконфигурированный для работы с n копиями P2.py через именованные каналы. Каждый P2.py будет считываться из соответствующей трубы.

Что, если один P2.py получит все данные "наихудшего случая" и запустится? Да, круговое движение не идеально. Но это лучше, чем только один P2.py, и вы можете устранить эту предвзятость с помощью простой рандомизации.

Включение вентилятора с нескольких P2.py на один P3.py немного сложнее. На данный момент подход старой школы перестает быть выгодным. P3.py необходимо читать из нескольких именованных каналов, используя библиотеку select, чтобы чередовать чтения.

Ответ 5

Вероятно, возможно ввести немного parallelism в часть 1. Вероятно, это не проблема с форматом, который так же прост, как CSV, но если обработка входных данных заметно медленнее, чем чтение данных, вы можете читать большие куски, а затем продолжать читать, пока не найдете "разделитель строк" ​​( newline в случае CSV, но опять же, что зависит от формата чтения, не работает, если формат достаточно сложный).

Эти куски, каждый из которых, вероятно, содержит несколько записей, затем могут быть обработаны до толпы параллельных процессов, считывающих задания с очереди, где они разбираются и разбиваются, а затем помещаются в очередь для этапа 2.