Giải quyết các vấn đề phức tạp song song bằng cách sử dụng đa xử lý Python

Làm thế nào để người ta sử dụng đa xử lý để giải quyết các vấn đề song song đáng xấu hổ ?

Các vấn đề song song phổ biến thường bao gồm ba phần cơ bản:

1. Đọc dữ liệu đầu vào (từ tệp, cơ sở dữ liệu, kết nối tcp, v.v.).
2. Chạy các phép tính trên dữ liệu đầu vào, trong đó mỗi phép tính độc lập với bất kỳ phép tính nào khác .
3. Ghi kết quả của các phép tính (vào tệp, cơ sở dữ liệu, kết nối tcp, v.v.).

Chúng ta có thể song song hóa chương trình theo hai chiều:

• Phần 2 có thể chạy trên nhiều lõi, vì mỗi phép tính là độc lập; thứ tự xử lý không quan trọng.
• Mỗi bộ phận có thể chạy độc lập. Phần 1 có thể đặt dữ liệu trên hàng đợi đầu vào, phần 2 có thể kéo dữ liệu ra khỏi hàng đợi đầu vào và đưa kết quả vào hàng đợi đầu ra, và phần 3 có thể kéo kết quả ra khỏi hàng đợi đầu ra và ghi chúng ra ngoài.

Đây có vẻ là một mẫu cơ bản nhất trong lập trình đồng thời, nhưng tôi vẫn chưa cố gắng giải quyết nó, vì vậy hãy viết một ví dụ chính tắc để minh họa cách thực hiện điều này bằng cách sử dụng đa xử lý .

Đây là vấn đề ví dụ: Cho một tệp CSV với các hàng số nguyên làm đầu vào, hãy tính tổng của chúng. Tách vấn đề thành ba phần, tất cả có thể chạy song song:

1. Xử lý tệp đầu vào thành dữ liệu thô (danh sách / lặp lại các số nguyên)
2. Tính toán tổng dữ liệu, song song
3. Xuất ra các tổng

Dưới đây là chương trình Python truyền thống, ràng buộc một quy trình giải quyết ba tác vụ sau:

#!/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:])

Hãy lấy chương trình này và viết lại nó để sử dụng đa xử lý để song song hóa ba phần được nêu ở trên. Dưới đây là khung của chương trình song song mới này, cần được bổ sung để giải quyết các phần trong nhận xét:

#!/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:])

Bạn có thể tìm thấy những đoạn mã này, cũng như một đoạn mã khác có thể tạo tệp CSV mẫu cho mục đích thử nghiệm trên github .

Tôi sẽ đánh giá cao bất kỳ cái nhìn sâu sắc nào ở đây về cách bạn các chuyên gia đồng thời sẽ tiếp cận vấn đề này.

Đây là một số câu hỏi tôi đã có khi nghĩ về vấn đề này. Điểm thưởng khi giải quyết bất kỳ / tất cả:

• Tôi có nên có các quy trình con để đọc dữ liệu và đặt nó vào hàng đợi hay quy trình chính có thể thực hiện việc này mà không bị chặn cho đến khi tất cả đầu vào được đọc không?
• Tương tự như vậy, tôi nên có một quy trình con để ghi kết quả ra khỏi hàng đợi đã xử lý hay quy trình chính có thể thực hiện việc này mà không cần phải đợi tất cả kết quả?
• Tôi có nên sử dụng một nhóm quy trình cho các phép tính tổng không?
  • Nếu có, tôi sẽ gọi phương thức nào trên pool để bắt đầu xử lý kết quả vào hàng đợi đầu vào, mà không chặn quá trình đầu vào và đầu ra? apply_async () ? map_async () ? imap () ? imap_unordered () ?
• Giả sử chúng ta không cần loại bỏ các hàng đợi đầu vào và đầu ra khi dữ liệu nhập vào chúng, nhưng có thể đợi cho đến khi tất cả đầu vào được phân tích cú pháp và tất cả kết quả được tính toán (ví dụ: vì chúng ta biết tất cả đầu vào và đầu ra sẽ nằm gọn trong bộ nhớ hệ thống). Chúng ta có nên thay đổi thuật toán theo bất kỳ cách nào (ví dụ: không chạy bất kỳ quy trình nào đồng thời với I / O) không?

Giải pháp của tôi có thêm một chuông và còi để đảm bảo rằng thứ tự của đầu ra giống với thứ tự của đầu vào. Tôi sử dụng multiprocessing.queue để gửi dữ liệu giữa các quy trình, gửi thông báo dừng để mỗi quy trình biết bỏ kiểm tra hàng đợi. Tôi nghĩ các bình luận trong nguồn nên làm rõ những gì đang xảy ra nhưng nếu không hãy cho tôi biết.

#!/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:])

Đến dự tiệc muộn ...

joblib có một lớp bên trên đa xử lý để giúp tạo song song cho các vòng lặp. Nó cung cấp cho bạn các tiện ích như điều phối công việc lười biếng và báo cáo lỗi tốt hơn ngoài cú pháp rất đơn giản của nó.

Với tư cách là người từ chối trách nhiệm, tôi là tác giả ban đầu của joblib.

Tôi nhận ra rằng tôi hơi trễ đến bữa tiệc, nhưng gần đây tôi đã phát hiện ra song song GNU và muốn cho thấy việc hoàn thành nhiệm vụ điển hình này dễ dàng như thế nào với nó.

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

Một cái gì đó như thế này sẽ làm cho 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)

Parallel sẽ chạy sum.pycho mọi dòng trong input.csv(tất nhiên là song song), sau đó xuất ra kết quả sums. Rõ ràng tốt hơn multiprocessingrắc rối

Trường cũ.

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

Đây là cấu trúc cuối cùng đa xử lý.

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

Có, vỏ đã kết nối chúng với nhau ở cấp hệ điều hành. Nó có vẻ đơn giản hơn đối với tôi và nó hoạt động rất độc đáo.

Có, có nhiều chi phí hơn trong việc sử dụng dưa chua (hoặc cPickle). Tuy nhiên, việc đơn giản hóa có vẻ đáng để nỗ lực.

Nếu bạn muốn tên tệp là một đối số p1.py, đó là một thay đổi dễ dàng.

Quan trọng hơn, một chức năng như sau rất tiện dụng.

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

Điều đó cho phép bạn làm điều này:

for item in get_stdin():
     process item

Điều này rất đơn giản, nhưng nó không dễ dàng cho phép bạn có nhiều bản sao của P2.py đang chạy.

Bạn có hai vấn đề: quạt ra và quạt vào. P1.py bằng cách nào đó phải tạo ra nhiều P2.py's. Và P2.py's bằng cách nào đó phải hợp nhất các kết quả của chúng thành một P3.py duy nhất.

Cách tiếp cận kiểu cũ đối với fan-out là một kiến ​​trúc "Đẩy", rất hiệu quả.

Về mặt lý thuyết, việc kéo nhiều P2.py từ một hàng đợi chung là sự phân bổ tài nguyên tối ưu. Điều này thường là lý tưởng, nhưng nó cũng là một lượng lập trình hợp lý. Lập trình có thực sự cần thiết? Hay quá trình xử lý theo vòng tròn sẽ đủ tốt?

Thực tế, bạn sẽ thấy rằng làm cho P1.py thực hiện một "vòng tròn" đơn giản đối phó giữa nhiều P2.py's có thể khá tốt. Bạn đã cấu hình P1.py để xử lý n bản sao của P2.py thông qua các đường ống được đặt tên. Mỗi P2.py's sẽ đọc từ đường ống thích hợp của họ.

Điều gì sẽ xảy ra nếu một P2.py nhận được tất cả dữ liệu "trường hợp xấu nhất" và chạy phía sau? Đúng, vòng tròn không hoàn hảo. Nhưng nó tốt hơn là chỉ một P2.py và bạn có thể giải quyết sự sai lệch này với ngẫu nhiên đơn giản.

Fan-in từ nhiều P2.py đến một P3.py phức tạp hơn một chút. Tại thời điểm này, cách tiếp cận kiểu cũ không còn là lợi thế nữa. P3.py cần đọc từ nhiều đường ống được đặt tên bằng cách sử dụng selectthư viện để xen kẽ các lần đọc.

Có lẽ cũng có thể giới thiệu một chút song song vào phần 1. Có thể không phải là vấn đề với định dạng đơn giản như CSV, nhưng nếu việc xử lý dữ liệu đầu vào chậm hơn đáng kể so với việc đọc dữ liệu, bạn có thể đọc các phần lớn hơn, sau đó tiếp tục đọc cho đến khi bạn tìm thấy "dấu phân cách hàng" ( dòng mới trong trường hợp CSV, nhưng lại phụ thuộc vào định dạng được đọc; không hoạt động nếu định dạng đủ phức tạp).

Các phần này, mỗi phần có thể chứa nhiều mục nhập, sau đó có thể được chuyển sang một đám đông các quy trình song song đọc các công việc ra khỏi hàng đợi, nơi chúng được phân tích cú pháp và phân tách, sau đó được đặt vào hàng đợi cho giai đoạn 2.