многопроцессорная обработка: совместное использование большого объекта только для чтения между процессами?

"Дочерние процессы, порожденные через многопроцессорные объекты доли, созданные ранее в программе?"

Процессы №

имеют независимое пространство памяти.

Решение 1

лучше всего использовать большую структуру с большим количеством рабочих, сделайте это.

1. Запись каждый рабочий как "фильтр" – промежуточные результаты чтений stdin, действительно работает, промежуточные результаты записей на stdout.

2. Подключение все рабочие как конвейер:

   process1 <source | process2 | process3 | ... | processn >result
   

Каждый процесс чтения, действительно работает и пишет.

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

Решение 2

В некоторых случаях, у Вас есть более сложная структура – часто структура "разветвления на выходе". В этом случае у Вас есть родитель с несколькими детьми.

1. Родитель открывает исходные данные. Родительские ветвления много детей.

2. Родительский источник чтений, сдает части в аренду источника каждому одновременно рабочему ребенку.

3. , Когда родитель достигнет конца, закройте канал. Ребенок получает конец файла и концов обычно.

дочерние части приятно записать, потому что каждый ребенок просто читает sys.stdin.

родитель имеет определенные необычные активные действия в порождении всех детей и сохранении каналов правильно, но это не слишком плохо.

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

Чтение из многих именованных каналов часто делается с помощью select модуль для наблюдения, какие каналы имеют вход ожидания.

Решение 3

Общий поиск является определением базы данных.

Решение 3A – загрузите базу данных. Позвольте рабочим обработать данные в базе данных.

Решение 3B – создайте очень простой сервер с помощью werkzeug (или подобный) для обеспечения приложений WSGI, которые отвечают на HTTP, ДОБИРАЮТСЯ так, рабочие могут запросить сервер.

объект Совместно используемой файловой системы Решения 4

. Unix ОС предлагает объекты общей памяти. Это просто файлы, которые отображаются на памяти так, чтобы свопинг ввода-вывода был сделан вместо буферизованных чтений большего количества конвенции.

можно сделать это от контекста Python несколькими способами

1. Запись программа запуска, которая (1) повреждает Ваш исходный гигантский объект в меньшие объекты и (2) запускает рабочих, каждого с меньшим объектом. Меньшие объекты могли быть солеными объектами Python сохранить крошечный бит времени считывания файла.

2. Запись программа запуска, что (1) чтения Ваш исходный гигантский объект и записи структурированный страницей, кодированный байтом файл с помощью seek операции, чтобы гарантировать, что отдельные разделы легко найти с простым, ищет. Это - то, что механизм базы данных делает – повредите данные в страницы, сделайте каждую страницу легкой расположиться через seek.

   рабочие Spawn с доступом этот этот большой структурированный страницей файл. Каждый рабочий может искать на соответствующие части и сделать их работу там.

Дочерние процессы, порожденные через многопроцессорные объекты доли, создали ранее в программе?

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

многопроцессорная обработка в документации говорится:

Better to inherit than pickle/unpickle

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

Explicitly pass resources to child processes

На Unix дочерний процесс может использовать совместно используемый ресурс, созданный в родительском процессе с помощью глобального ресурса. Однако лучше передать объект как аргумент конструктору для дочернего процесса.

Кроме создания кода (потенциально) совместимого с Windows, это также гарантирует, что, пока дочерний процесс все еще жив, объект не будет собран "мусор" в родительском процессе. Это могло бы быть важно, если некоторый ресурс освобожден, когда объект собран "мусор" в родительском процессе.

Global variables

Принимают во внимание, что, если код, выполненный в дочернем процессе, пытается получить доступ к глобальной переменной, то значение он видит (если таковые имеются) может не совпасть со значением в родительском процессе в то время, когда Process.start () назвали.

Пример

В Windows (единственный ЦП):

#!/usr/bin/env python
import os, sys, time
from multiprocessing import Pool

x = 23000 # replace `23` due to small integers share representation
z = []    # integers are immutable, let's try mutable object

def printx(y):
    global x
    if y == 3:
       x = -x
    z.append(y)
    print os.getpid(), x, id(x), z, id(z) 
    print y
    if len(sys.argv) == 2 and sys.argv[1] == "sleep":
       time.sleep(.1) # should make more apparant the effect

if __name__ == '__main__':
    pool = Pool(processes=4)
    pool.map(printx, (1,2,3,4))

С sleep:

$ python26 test_share.py sleep
2504 23000 11639492 [1] 10774408
1
2564 23000 11639492 [2] 10774408
2
2504 -23000 11639384 [1, 3] 10774408
3
4084 23000 11639492 [4] 10774408
4

Без sleep:

$ python26 test_share.py
1148 23000 11639492 [1] 10774408
1
1148 23000 11639492 [1, 2] 10774408
2
1148 -23000 11639324 [1, 2, 3] 10774408
3
1148 -23000 11639324 [1, 2, 3, 4] 10774408
4

S.Lott корректен. Многопроцессорные ярлыки Python эффективно дают Вам отдельный, дублированный блок памяти.

На большинстве *отклоняют системы, использование вызова низшего уровня к os.fork(), на самом деле, даст Вам память копии на записи, которая могла бы быть тем, что Вы думаете. AFAIK, в теории, в самой упрощенной из возможных программ, Вы могли читать из тех данных, не копируя его.

Однако вещи не вполне настолько просты в интерпретаторе Python. Данные объектов и метаданные хранятся в том же сегменте памяти, поэтому даже если объект никогда не будет изменяться, то что-то как ссылочный счетчик для того увеличиваемого объекта вызовет запись памяти и поэтому копию. Почти любая программа Python, которая делает больше, чем "печать 'привет'", вызовет инкременты подсчета ссылок, таким образом, Вы никогда не будете, вероятно, осознавать преимущества копии на записи.

, Даже если бы кому-то действительно удавалось взломать решение общей памяти в Python, пытаясь скоординировать сборку "мусора" через процессы, вероятно, было бы довольно болезненным.

Если Вы работаете под Unix, они могут совместно использовать тот же объект, из-за , как ветвление работает (т.е. дочерние процессы имеют отдельную память, но это - копия на записи, таким образом, это может быть совместно использовано, пока никто не изменяет его). Я попробовал следующее:

import multiprocessing

x = 23

def printx(y):
    print x, id(x)
    print y

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    pool.map(printx, (1,2,3,4))

и получил следующий вывод:

$ ./mtest.py
23 22995656
1
23 22995656
2
23 22995656
3
23 22995656
4

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

Различные процессы имеют другое адресное пространство. Как выполнение различных экземпляров интерпретатора. Это - то, для чего IPC (межпроцессное взаимодействие).

можно использовать или очереди или каналы с этой целью. Можно также использовать rpc по tcp, если Вы хотите распределить процессы по сети позже.

http://docs.python.org/dev/library/multiprocessing.html#exchanging-objects-between-processes

Не непосредственно связанный с многопроцессорной обработкой по сути, но от Вашего примера, казалось бы, что Вы могли просто использовать эти , откладывают модуль или что-то как этот. "big_lookup_object" должен действительно быть полностью в памяти?