Як можна використовувати багатопроцесорну обробку для вирішення незручно паралельних проблем ?
Незвично паралельні проблеми, як правило, складаються з трьох основних частин:
- Зчитування вхідних даних (з файлу, бази даних, з'єднання tcp тощо).
- Запустіть обчислення на вхідних даних, де кожен розрахунок не залежить від будь-якого іншого обчислення .
- Запишіть результати обчислень (у файл, базу даних, з'єднання TCP тощо).
Ми можемо розпаралелювати програму у двох вимірах:
- Частина 2 може працювати на декількох ядрах, оскільки кожне обчислення є незалежним; порядок обробки не має значення.
- Кожна частина може працювати самостійно. Частина 1 може розміщувати дані у вхідній черзі, частина 2 може витягувати дані з вхідної черги та розміщувати результати у вихідній черзі, а частина 3 може витягувати результати з вихідної черги та записувати їх.
Це здається найосновнішим шаблоном при одночасному програмуванні, але я все ще втрачаю спроби його вирішити, тому давайте напишемо канонічний приклад, щоб проілюструвати, як це робиться за допомогою багатопроцесорної обробки .
Ось приклад проблеми: Давши CSV-файл із рядками цілих чисел як вхідними, обчисліть їх суми. Розділіть проблему на три частини, які можуть виконуватися паралельно:
- Обробка вхідного файлу в необроблені дані (списки / ітерабелі цілих чисел)
- Паралельно обчислюйте суми даних
- Виведіть суми
Нижче наведено традиційну програму Python, прив'язану до одного процесу, яка вирішує ці три завдання:
#!/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:])
Візьмемо цю програму і перепишемо її, щоб використовувати багатопроцесорну обробку для паралелізації трьох частин, описаних вище. Нижче наведено скелет цієї нової, розпаралелізованої програми, яку потрібно доопрацювати, щоб звернутися до частин у коментарях:
#!/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:])
Ці фрагменти коду, а також інший фрагмент коду, який може генерувати приклади файлів CSV для цілей тестування, можна знайти на github .
Я був би вдячний за будь-яке розуміння тут того, як ви, гуру паралелізму, підійдете до цієї проблеми.
Ось декілька запитань, які виникали у мене, коли я думав про цю проблему. Бонусні бали за адресу будь-якого / усіх:
- Чи повинен я мати дочірні процеси для зчитування даних та розміщення їх у черзі, чи може основний процес робити це, не блокуючи, поки не буде прочитано весь вхід?
- Так само, чи повинен я мати дочірній процес для виписування результатів із обробленої черги, чи може основний процес робити це, не чекаючи всіх результатів?
- Чи слід використовувати пул процесів для операцій суми?
- Якщо так, який метод я закликаю до пулу, щоб він почав обробляти результати, що надходять у чергу введення, не блокуючи також процеси введення та виводу? apply_async () ? map_async () ? imap () ? imap_unordered () ?
- Припустимо, нам не потрібно було відсікати черги вводу та виводу під час введення даних, але ми могли дочекатися, поки все введення буде проаналізовано та обчислені всі результати (наприклад, тому що ми знаємо, що всі вхідні та вихідні дані помістяться в системній пам’яті). Чи повинні ми якось змінювати алгоритм (наприклад, не запускати жодні процеси одночасно з введенням / виведенням)?