बहुविकल्पी में साझा की गई मेमोरी ऑब्जेक्ट्स

Question

मान लीजिए कि मेरे पास मेमोरी सुपीरियर सरणी में एक बड़ा है, मेरे पास एक फ़ंक्शन है funcजो इनपुट के रूप में इस विशाल सरणी में लेता है (कुछ अन्य मापदंडों के साथ)। funcविभिन्न मापदंडों के साथ समानांतर में चलाया जा सकता है। उदाहरण के लिए:

def func(arr, param):
    # do stuff to arr, param

# build array arr

pool = Pool(processes = 6)
results = [pool.apply_async(func, [arr, param]) for param in all_params]
output = [res.get() for res in results]

यदि मैं मल्टीप्रोसेसिंग लाइब्रेरी का उपयोग करता हूं, तो उस विशाल सरणी को कई बार विभिन्न प्रक्रियाओं में कॉपी किया जाएगा।

क्या विभिन्न प्रक्रियाओं को एक ही सरणी को साझा करने का एक तरीका है? यह सरणी ऑब्जेक्ट केवल-पढ़ने के लिए है और इसे कभी भी संशोधित नहीं किया जाएगा।

क्या अधिक जटिल है, अगर गिरफ्तारी एक सरणी नहीं है, लेकिन एक मनमाना अजगर वस्तु है, क्या इसे साझा करने का कोई तरीका है?

[संपादित]

मैंने जवाब पढ़ा लेकिन मैं अभी भी थोड़ा उलझन में हूं। चूंकि कांटा () कॉपी-ऑन-राइट है, इसलिए हमें अजगर मल्टीप्रोसेसिंग लाइब्रेरी में नई प्रक्रियाओं को शुरू करते समय किसी भी अतिरिक्त लागत का आह्वान नहीं करना चाहिए। लेकिन निम्नलिखित कोड से पता चलता है कि एक बहुत बड़ा ओवरहेड है:

from multiprocessing import Pool, Manager
import numpy as np; 
import time

def f(arr):
    return len(arr)

t = time.time()
arr = np.arange(10000000)
print "construct array = ", time.time() - t;


pool = Pool(processes = 6)

t = time.time()
res = pool.apply_async(f, [arr,])
res.get()
print "multiprocessing overhead = ", time.time() - t;

आउटपुट (और वैसे, लागत बढ़ जाती है क्योंकि सरणी का आकार बढ़ जाता है, इसलिए मुझे संदेह है कि मेमोरी मेमोरी से संबंधित ओवरहेड अभी भी है):

construct array =  0.0178790092468
multiprocessing overhead =  0.252444982529

अगर हम सरणी की नकल नहीं करते हैं, तो इतना बड़ा ओवरहेड क्यों है? और साझा स्मृति मुझे किस हिस्से को बचाती है?

Comments

संभव के डुप्लिकेट को साझा किया गया है जिसे पायथन मल्टीप्रोसेसिंग के लिए अलग-अलग प्रक्रियाओं में साझा किया गया है?

— फ्रांसिस अवीला

आपने डॉक्स को देखा है , है ना?

— लेव लेवित्स्की

@FrancisAvila न केवल सरणी, बल्कि मनमानी अजगर वस्तुओं को साझा करने का एक तरीका है?

— वेंडेटा

@LevLevitsky मुझे पूछना है, क्या न केवल सरणी, बल्कि मनमानी अजगर वस्तुओं को साझा करने का एक तरीका है?

— वेंडेटा

यह उत्तर स्पष्ट रूप से बताता है कि क्यों मनमानी अजगर वस्तुओं को साझा नहीं किया जा सकता है।

— जने करिला

Answer 1

यदि आप एक ऑपरेटिंग सिस्टम का उपयोग करते हैं जो कॉपी-ऑन-राइट fork()शब्दार्थ (किसी भी सामान्य यूनिक्स की तरह) का उपयोग करता है , तो जब तक आप अपनी डेटा संरचना को कभी नहीं बदलते हैं, यह अतिरिक्त मेमोरी लेने के बिना सभी बच्चे प्रक्रियाओं के लिए उपलब्ध होगा। आपको कुछ विशेष नहीं करना होगा (इसके अलावा पूरी तरह से सुनिश्चित करें कि आप ऑब्जेक्ट को बदल नहीं सकते हैं)।

अपनी समस्या के लिए आप जो सबसे कुशल काम कर सकते हैं, वह यह है कि आप अपने सरणी को एक कुशल सरणी संरचना (उपयोग numpyया array) में रखें, जो कि साझा की गई मेमोरी में हो, उसे अपने साथ लपेटें multiprocessing.Array, और उसे अपने कार्यों में पास करें। यह उत्तर दिखाता है कि यह कैसे करना है ।

यदि आप एक लेखन योग्य साझा वस्तु चाहते हैं , तो आपको इसे किसी प्रकार के सिंक्रनाइज़ेशन या लॉकिंग के साथ लपेटना होगा। ऐसा करने की दो विधियाँmultiprocessing प्रदान करता है : एक साझा मेमोरी (सरल मान, सरण, या ctypes के लिए उपयुक्त) या एक प्रॉक्सी का उपयोग करके, जहाँ एक प्रक्रिया में मेमोरी होती है और एक प्रबंधक अन्य प्रक्रियाओं (यहां तक ​​कि एक नेटवर्क पर) तक पहुँच प्राप्त करता है।Manager

Managerदृष्टिकोण मनमाना पायथन वस्तुओं के साथ इस्तेमाल किया जा सकता है, लेकिन बराबर का उपयोग कर साझा स्मृति की तुलना में धीमी हो जाएगा क्योंकि वस्तुओं धारावाहिक जा करने के लिए / deserialized और प्रक्रियाओं के बीच भेजा जरूरत है।

पायथन में उपलब्ध समानांतर प्रसंस्करण पुस्तकालयों और दृष्टिकोणों का खजाना हैं । multiprocessingएक उत्कृष्ट और अच्छी तरह से गोल पुस्तकालय है, लेकिन अगर आपके पास विशेष आवश्यकताएं हैं तो शायद अन्य दृष्टिकोणों में से एक बेहतर हो सकता है।

Comments

बस ध्यान देने के लिए, पायथन फोर्क पर () का अर्थ वास्तव में एक्सेस पर कॉपी है (क्योंकि सिर्फ ऑब्जेक्ट को एक्सेस करने से इसकी रिफ-काउंट बदल जाएगी)।

— फैबियो ज़द्रोज़नी

@FabioZadrozny क्या यह वास्तव में संपूर्ण ऑब्जेक्ट की प्रतिलिपि बना सकता है, या सिर्फ मेमोरी पेज होगा जिसमें इसका रिफकाउंट है?

— जिग

AFAIK, केवल मेमोरी पेज जिसमें रिफकाउंट होता है (इसलिए, प्रत्येक ऑब्जेक्ट एक्सेस पर 4kb)।

— फाबियो ज़ादोज़नी 18

@ मोम एक बंद का उपयोग करें। दिए गए फ़ंक्शन को apply_asyncअपने तर्कों के माध्यम से सीधे साझा ऑब्जेक्ट को दायरे में संदर्भित करना चाहिए।

— फ्रांसिस अविला

@FrancisAvila आप एक बंद का उपयोग कैसे करते हैं? क्या फ़ंक्शन जिसे आप apply_async को देते हैं, उसे लेने योग्य नहीं होना चाहिए? या यह केवल एक map_async प्रतिबंध है?

— जर्मनके

Answer 2

मैं उसी समस्या में भागता हूं और इसके चारों ओर काम करने के लिए थोड़ा सा साझा-मेमोरी उपयोगिता वर्ग लिखा है।

मैं multiprocessing.RawArray(लॉकफ्री) का उपयोग कर रहा हूं , और सरणियों तक पहुंच बिल्कुल भी लॉक नहीं है (लॉकफ्री), अपने खुद के पैरों को शूट करने के लिए सावधान रहें।

समाधान के साथ मुझे क्वाड-कोर i7 पर लगभग 3 के कारक द्वारा स्पीडअप मिलता है।

यहाँ कोड है: इसे इस्तेमाल करने और सुधारने के लिए स्वतंत्र महसूस करें, और कृपया किसी भी बग की रिपोर्ट करें।

'''
Created on 14.05.2013

@author: martin
'''

import multiprocessing
import ctypes
import numpy as np

class SharedNumpyMemManagerError(Exception):
    pass

'''
Singleton Pattern
'''
class SharedNumpyMemManager:    

    _initSize = 1024

    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(SharedNumpyMemManager, cls).__new__(
                                cls, *args, **kwargs)
        return cls._instance        

    def __init__(self):
        self.lock = multiprocessing.Lock()
        self.cur = 0
        self.cnt = 0
        self.shared_arrays = [None] * SharedNumpyMemManager._initSize

    def __createArray(self, dimensions, ctype=ctypes.c_double):

        self.lock.acquire()

        # double size if necessary
        if (self.cnt >= len(self.shared_arrays)):
            self.shared_arrays = self.shared_arrays + [None] * len(self.shared_arrays)

        # next handle
        self.__getNextFreeHdl()        

        # create array in shared memory segment
        shared_array_base = multiprocessing.RawArray(ctype, np.prod(dimensions))

        # convert to numpy array vie ctypeslib
        self.shared_arrays[self.cur] = np.ctypeslib.as_array(shared_array_base)

        # do a reshape for correct dimensions            
        # Returns a masked array containing the same data, but with a new shape.
        # The result is a view on the original array
        self.shared_arrays[self.cur] = self.shared_arrays[self.cnt].reshape(dimensions)

        # update cnt
        self.cnt += 1

        self.lock.release()

        # return handle to the shared memory numpy array
        return self.cur

    def __getNextFreeHdl(self):
        orgCur = self.cur
        while self.shared_arrays[self.cur] is not None:
            self.cur = (self.cur + 1) % len(self.shared_arrays)
            if orgCur == self.cur:
                raise SharedNumpyMemManagerError('Max Number of Shared Numpy Arrays Exceeded!')

    def __freeArray(self, hdl):
        self.lock.acquire()
        # set reference to None
        if self.shared_arrays[hdl] is not None: # consider multiple calls to free
            self.shared_arrays[hdl] = None
            self.cnt -= 1
        self.lock.release()

    def __getArray(self, i):
        return self.shared_arrays[i]

    @staticmethod
    def getInstance():
        if not SharedNumpyMemManager._instance:
            SharedNumpyMemManager._instance = SharedNumpyMemManager()
        return SharedNumpyMemManager._instance

    @staticmethod
    def createArray(*args, **kwargs):
        return SharedNumpyMemManager.getInstance().__createArray(*args, **kwargs)

    @staticmethod
    def getArray(*args, **kwargs):
        return SharedNumpyMemManager.getInstance().__getArray(*args, **kwargs)

    @staticmethod    
    def freeArray(*args, **kwargs):
        return SharedNumpyMemManager.getInstance().__freeArray(*args, **kwargs)

# Init Singleton on module load
SharedNumpyMemManager.getInstance()

if __name__ == '__main__':

    import timeit

    N_PROC = 8
    INNER_LOOP = 10000
    N = 1000

    def propagate(t):
        i, shm_hdl, evidence = t
        a = SharedNumpyMemManager.getArray(shm_hdl)
        for j in range(INNER_LOOP):
            a[i] = i

    class Parallel_Dummy_PF:

        def __init__(self, N):
            self.N = N
            self.arrayHdl = SharedNumpyMemManager.createArray(self.N, ctype=ctypes.c_double)            
            self.pool = multiprocessing.Pool(processes=N_PROC)

        def update_par(self, evidence):
            self.pool.map(propagate, zip(range(self.N), [self.arrayHdl] * self.N, [evidence] * self.N))

        def update_seq(self, evidence):
            for i in range(self.N):
                propagate((i, self.arrayHdl, evidence))

        def getArray(self):
            return SharedNumpyMemManager.getArray(self.arrayHdl)

    def parallelExec():
        pf = Parallel_Dummy_PF(N)
        print(pf.getArray())
        pf.update_par(5)
        print(pf.getArray())

    def sequentialExec():
        pf = Parallel_Dummy_PF(N)
        print(pf.getArray())
        pf.update_seq(5)
        print(pf.getArray())

    t1 = timeit.Timer("sequentialExec()", "from __main__ import sequentialExec")
    t2 = timeit.Timer("parallelExec()", "from __main__ import parallelExec")

    print("Sequential: ", t1.timeit(number=1))    
    print("Parallel: ", t2.timeit(number=1))

Comments

बस एहसास हुआ कि आपको मल्टीप्रोसेसिंग पूल बनाने से पहले अपनी साझा मेमोरी एरेज़ को सेट करना होगा, न जाने क्यों अभी तक लेकिन यह निश्चित रूप से दूसरे तरीके से काम नहीं करेगा।

— martin.preinfalk 15

यही कारण है कि जब पूल को त्वरित किया जाता है, तो मल्टीप्रोसेसिंग पूल कांटा () कहता है, इसलिए उसके बाद किसी भी साझा किए गए मेम के लिए पॉइंटर तक पहुंच प्राप्त नहीं होगी।

— Xiv

जब मैंने py35 के तहत इस कोड को आज़माया तो मुझे multiprocessing.sedenctypes.py में अपवाद मिला, इसलिए मुझे लगता है कि यह कोड केवल py2 के लिए है।

— डॉ। हिलियर डैनियल

Answer 3

यह रे के लिए इच्छित उपयोग का मामला है , जो समानांतर और वितरित पायथन के लिए एक पुस्तकालय है। हुड के तहत, यह अपाचे एरो डेटा लेआउट (जो कि एक शून्य-कॉपी प्रारूप है) का उपयोग करके वस्तुओं को क्रमबद्ध करता है और उन्हें एक साझा-मेमोरी ऑब्जेक्ट स्टोर में संग्रहीत करता है ताकि उन्हें कॉपी बनाए बिना कई प्रक्रियाओं द्वारा एक्सेस किया जा सके।

कोड निम्नलिखित की तरह दिखेगा।

import numpy as np
import ray

ray.init()

@ray.remote
def func(array, param):
    # Do stuff.
    return 1

array = np.ones(10**6)
# Store the array in the shared memory object store once
# so it is not copied multiple times.
array_id = ray.put(array)

result_ids = [func.remote(array_id, i) for i in range(4)]
output = ray.get(result_ids)

यदि आप कॉल नहीं करते हैं, ray.putतो सरणी को अभी भी साझा मेमोरी में संग्रहीत किया जाएगा, लेकिन यह एक बार मंगलाचरण के अनुसार किया जाएगा func, जो कि आप नहीं चाहते हैं।

ध्यान दें कि यह न केवल सरणियों के लिए काम करेगा, बल्कि उन वस्तुओं के लिए भी होगा जिनमें सरणियाँ हैं , उदाहरण के लिए, नीचे दिए गए सरणियों के लिए ints का मानचित्रण करना।

आप IPython में निम्नलिखित को चलाकर Ray बनाम अचार में क्रमांकन के प्रदर्शन की तुलना कर सकते हैं।

import numpy as np
import pickle
import ray

ray.init()

x = {i: np.ones(10**7) for i in range(20)}

# Time Ray.
%time x_id = ray.put(x)  # 2.4s
%time new_x = ray.get(x_id)  # 0.00073s

# Time pickle.
%time serialized = pickle.dumps(x)  # 2.6s
%time deserialized = pickle.loads(serialized)  # 1.9s

रे के साथ सीरियलाइजेशन अचार की तुलना में केवल थोड़ा तेज है, लेकिन साझा मेमोरी के उपयोग के कारण डिसेरिएलाइजेशन 1000 गुना तेज है (यह संख्या निश्चित रूप से ऑब्जेक्ट पर निर्भर करेगी)।

रे प्रलेखन देखें । आप रे और तीर का उपयोग करके तेजी से क्रमांकन के बारे में अधिक पढ़ सकते हैं । नोट मैं रे डेवलपर्स में से एक हूं।

Comments

अच्छा लगता है रे! लेकिन, मैंने पहले इस पुस्तकालय का उपयोग करने की कोशिश की है, लेकिन दुर्भाग्य से, मुझे बस एहसास हुआ कि रे खिड़कियों का समर्थन नहीं करता है। मुझे उम्मीद है कि आप लोग ASAP की खिड़कियों का समर्थन कर सकते हैं। धन्यवाद, डेवलपर्स!

— हज़्किग्स्क

Answer 4

जैसा कि रॉबर्ट निशिहारा ने उल्लेख किया है, अपाचे एरो इसे आसान बनाता है, विशेष रूप से प्लाज्मा इन-मेमोरी ऑब्जेक्ट स्टोर के साथ, जो कि रे पर बनाया गया है।

मैंने मस्तिष्क-प्लाज्मा को विशेष रूप से इस कारण से बनाया है - एक फ्लास्क ऐप में बड़ी वस्तुओं को तेजी से लोड करना और फिर से लोड करना। यह Apache Arrow-serializable ऑब्जेक्ट्स के लिए एक साझा-मेमोरी ऑब्जेक्ट नेमस्पेस है, जिसमें pickle'd bytestrings द्वारा जनरेट किया गया है pickle.dumps(...)।

Apache Ray और Plasma के साथ मुख्य अंतर यह है कि यह आपके लिए ऑब्जेक्ट आईडी का ट्रैक रखता है। कोई भी प्रक्रिया या थ्रेड या प्रोग्राम जो स्थानीय रूप से चल रहे हैं, किसी भी Brainऑब्जेक्ट से नाम कॉल करके वेरिएबल्स के मूल्यों को साझा कर सकते हैं ।

$ pip install brain-plasma

$ plasma_store -m 10000000 -s /tmp/plasma

from brain_plasma import Brain
brain = Brain(path='/tmp/plasma/)

brain['a'] = [1]*10000

brain['a']
# >>> [1,1,1,1,...]