다중 처리 : 여러 프로세스간에 사전을 공유하려면 어떻게합니까?


113

결합 가능한 대기열에서 작동하는 여러 프로세스를 생성 Q하고 D결과를 저장하기 위해 결국 전역 사전 을 조작 할 수있는 프로그램입니다 . (따라서 각 하위 프로세스는 D결과를 저장하고 다른 하위 프로세스가 생성하는 결과를 확인하는 데 사용할 수 있습니다 )

하위 프로세스에서 사전 D를 인쇄하면 그 (예 : D)에서 수정 된 내용을 볼 수 있습니다. 하지만 메인 프로세스가 Q에 합류 한 후 D를 인쇄하면 빈 딕셔너리입니다!

동기화 / 잠금 문제라는 것을 이해합니다. 누군가 여기서 무슨 일이 일어나고 있는지 그리고 어떻게 D에 대한 액세스를 동기화 할 수 있는지 말해 줄 수 있습니까?


1
이것은 osx 10.14.4를 사용하는 python 3.7.2에서 예상대로 작동하지 않습니다. Dict가 동기화되지 않고 다른 프로세스에 의해 내용이 다시 작성됩니다. 그러나 <code> multiprocessing.Manager (). list () </ code>는 예상대로 작동합니다.
Andrew Druchenko 19.04.02

답변:


162

일반적인 대답은 Manager객체 를 사용하는 것입니다. 문서에서 수정 :

from multiprocessing import Process, Manager

def f(d):
    d[1] += '1'
    d['2'] += 2

if __name__ == '__main__':
    manager = Manager()

    d = manager.dict()
    d[1] = '1'
    d['2'] = 2

    p1 = Process(target=f, args=(d,))
    p2 = Process(target=f, args=(d,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

    print d

산출:

$ python mul.py 
{1: '111', '2': 6}

4
감사합니다. 실제로 D = multiprocessing.Manager (). dict ()는 내 문제를 해결합니다. 나는 D = dict ()를 사용하고 있었다.
dop

3
@LorenzoBelli, 관리자에 대한 액세스가 동기화되어 있는지 묻는다면 대답은 '예'라고 생각합니다. multiprocessing.Manager()인스턴스를SyncManager 반환하며 그 이름은 많은 것을 제안합니다!
senderle 2011

@senderle 부모 프로세스의 무작위 상태를 자식 프로세스와 공유하고 싶습니다. 나는 사용해 Manager보았지만 여전히 운이 없습니다. 여기 에서 제 질문을 살펴보고 해결책을 제공 할 수 있는지 확인해 주시겠습니까? 난수를 np.random.seed(None)생성 할 때마다 다른 난수를 얻을 수 있지만, 이로 인해 내가 원하는 것이 아닌 부모 프로세스의 임의 상태를 사용할 수 없습니다. 어떤 도움이라도 대단히 감사합니다.
아미르

1
@RadioControlled는 업데이트를 작성하게되어 기쁩니다.하지만 간단히 말해서 직접이 작업을 수행 할 수는 없다고 생각하지만 동일한 키와 값으로 새 관리 딕셔너리를 쉽게 만들고 원본 대신 사용할 수 있습니다. 귀하의 경우에 적합합니까?
senderle

1
@senderle, 그게 내가 한 일입니다. 그래서 대답은 당신이 그렇게해야한다는 것입니다.
무선 제어

25

다중 처리는 스레딩과 다릅니다. 각 하위 프로세스는 기본 프로세스의 메모리 사본을받습니다. 일반적으로 상태는 통신 (파이프 / 소켓), 신호 또는 공유 메모리를 통해 공유됩니다.

다중 처리는 사용 사례에 대해 일부 추상화를 제공합니다-프록시 또는 공유 메모리를 사용하여 로컬로 처리되는 공유 상태 : http://docs.python.org/library/multiprocessing.html#sharing-state-between-processes

관련 섹션 :


1
감사합니다. 당신은 나를 해결책으로 이끌었습니다 : multiprocessing.Manager (). dict ().
dop

누군가 "각 하위 프로세스가 주 프로세스의 메모리 사본을 받게된다"는 말이 의미하는 바를 자세히 설명 할 수 있습니까?
Itsme2003

@ Itsme2003 기본적으로 생성 된 프로세스는 부모 프로세스의 메모리에 액세스 할 수 없습니다 (이것은 스레드의 주요 차이점 중 하나입니다). 따라서 프로세스에 부모 프로세스의 개체가 필요할 때 실제 개체에 대한 참조를 가져 오는 대신 복사본을 만들어야합니다. 위의 답변은 프로세스간에 객체를 공유하는 방법에 대해 자세히 설명합니다.
Niklas Mertsch

이것은 종종 착각되기 때문입니다. 최소한 일반적인 Linux 설정에서 객체를 수정하지 않는 한 객체는 실제로 메모리에 한 번만 저장됩니다. 변경되는 즉시 복사됩니다. 이는 메모리를 절약하고 개체를 수정하지 않아도되는 경우 매우 중요 할 수 있습니다.
라디오 제어

16

관리자의 딕셔너리보다 빠르고, 많은 메모리를 사용하고 Mac OS에서 작동하지 않는 pyshmht 라이브러리보다 더 간단하고 안정적인 내 작업을 공유하고 싶습니다. 내 사전은 일반 문자열에서만 작동하며 현재는 변경할 수 없습니다. 선형 프로빙 구현을 사용하고 테이블 뒤에 별도의 메모리 블록에 키와 값 쌍을 저장합니다.

from mmap import mmap
import struct
from timeit import default_timer
from multiprocessing import Manager
from pyshmht import HashTable


class shared_immutable_dict:
    def __init__(self, a):
        self.hs = 1 << (len(a) * 3).bit_length()
        kvp = self.hs * 4
        ht = [0xffffffff] * self.hs
        kvl = []
        for k, v in a.iteritems():
            h = self.hash(k)
            while ht[h] != 0xffffffff:
                h = (h + 1) & (self.hs - 1)
            ht[h] = kvp
            kvp += self.kvlen(k) + self.kvlen(v)
            kvl.append(k)
            kvl.append(v)

        self.m = mmap(-1, kvp)
        for p in ht:
            self.m.write(uint_format.pack(p))
        for x in kvl:
            if len(x) <= 0x7f:
                self.m.write_byte(chr(len(x)))
            else:
                self.m.write(uint_format.pack(0x80000000 + len(x)))
            self.m.write(x)

    def hash(self, k):
        h = hash(k)
        h = (h + (h >> 3) + (h >> 13) + (h >> 23)) * 1749375391 & (self.hs - 1)
        return h

    def get(self, k, d=None):
        h = self.hash(k)
        while True:
            x = uint_format.unpack(self.m[h * 4:h * 4 + 4])[0]
            if x == 0xffffffff:
                return d
            self.m.seek(x)
            if k == self.read_kv():
                return self.read_kv()
            h = (h + 1) & (self.hs - 1)

    def read_kv(self):
        sz = ord(self.m.read_byte())
        if sz & 0x80:
            sz = uint_format.unpack(chr(sz) + self.m.read(3))[0] - 0x80000000
        return self.m.read(sz)

    def kvlen(self, k):
        return len(k) + (1 if len(k) <= 0x7f else 4)

    def __contains__(self, k):
        return self.get(k, None) is not None

    def close(self):
        self.m.close()

uint_format = struct.Struct('>I')


def uget(a, k, d=None):
    return to_unicode(a.get(to_str(k), d))


def uin(a, k):
    return to_str(k) in a


def to_unicode(s):
    return s.decode('utf-8') if isinstance(s, str) else s


def to_str(s):
    return s.encode('utf-8') if isinstance(s, unicode) else s


def mmap_test():
    n = 1000000
    d = shared_immutable_dict({str(i * 2): '1' for i in xrange(n)})
    start_time = default_timer()
    for i in xrange(n):
        if bool(d.get(str(i))) != (i % 2 == 0):
            raise Exception(i)
    print 'mmap speed: %d gets per sec' % (n / (default_timer() - start_time))


def manager_test():
    n = 100000
    d = Manager().dict({str(i * 2): '1' for i in xrange(n)})
    start_time = default_timer()
    for i in xrange(n):
        if bool(d.get(str(i))) != (i % 2 == 0):
            raise Exception(i)
    print 'manager speed: %d gets per sec' % (n / (default_timer() - start_time))


def shm_test():
    n = 1000000
    d = HashTable('tmp', n)
    d.update({str(i * 2): '1' for i in xrange(n)})
    start_time = default_timer()
    for i in xrange(n):
        if bool(d.get(str(i))) != (i % 2 == 0):
            raise Exception(i)
    print 'shm speed: %d gets per sec' % (n / (default_timer() - start_time))


if __name__ == '__main__':
    mmap_test()
    manager_test()
    shm_test()

내 노트북 ​​성능 결과는 다음과 같습니다.

mmap speed: 247288 gets per sec
manager speed: 33792 gets per sec
shm speed: 691332 gets per sec

간단한 사용 예 :

ht = shared_immutable_dict({'a': '1', 'b': '2'})
print ht.get('a')

14
Github? 선적 서류 비치? 이 도구를 어떻게 사용할 수 있습니까?
Pavlos Panteliadis

10

@ senderle 's here 외에도 일부 사용자는의 기능을 사용하는 방법을 궁금해 할 수도 있습니다 multiprocessing.Pool.

좋은 점은 최상위 수준의 모든 친숙한 API를 모방 .Pool()하는 manager인스턴스 메서드 가 있다는 것입니다 multiprocessing.

from itertools import repeat
import multiprocessing as mp
import os
import pprint

def f(d: dict) -> None:
    pid = os.getpid()
    d[pid] = "Hi, I was written by process %d" % pid

if __name__ == '__main__':
    with mp.Manager() as manager:
        d = manager.dict()
        with manager.Pool() as pool:
            pool.map(f, repeat(d, 10))
        # `d` is a DictProxy object that can be converted to dict
        pprint.pprint(dict(d))

산출:

$ python3 mul.py 
{22562: 'Hi, I was written by process 22562',
 22563: 'Hi, I was written by process 22563',
 22564: 'Hi, I was written by process 22564',
 22565: 'Hi, I was written by process 22565',
 22566: 'Hi, I was written by process 22566',
 22567: 'Hi, I was written by process 22567',
 22568: 'Hi, I was written by process 22568',
 22569: 'Hi, I was written by process 22569',
 22570: 'Hi, I was written by process 22570',
 22571: 'Hi, I was written by process 22571'}

이것은 각 프로세스가 해당 프로세스 ID를 전역 DictProxy개체에 기록하는 약간 다른 예 d입니다.


3

아마도 파이썬 용 메모리 기반 해시 테이블 확장을 공유하는 pyshmht 를 시도해 볼 수 있습니다 .

주의

  1. 참고 용으로 완전히 테스트되지 않았습니다.

  2. 현재 다중 처리를위한 잠금 / sem 메커니즘이 없습니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.