केवल पायथन में मुफ्त पढ़ने के लिए लॉक करें?

Question

मैं कुछ बुनियादी प्रदर्शन और स्मृति की खपत मानक किया है और अगर वहाँ बातें भी तेजी से बनाने के लिए किसी भी तरह से है मैं सोच रहा था ...

1. मैं एक numpy ndarray के साथ एक विशाल 70,000 तत्व सूची है, और कहा गया सूची में एक tuple में फ़ाइल पथ।

2. मेरा पहला संस्करण अजगर मल्टीप्रोसेस मॉड्यूल में प्रक्रियाओं में से प्रत्येक के लिए सूची का एक कटा हुआ प्रतिलिपि पारित कर दिया है, लेकिन यह 20 से अधिक गीगाबाइट

3. दूसरे संस्करण मैं इसे में चले गए करने के लिए राम उपयोग विस्फोट कर दे वैश्विक अंतरिक्ष और इसे मेरी प्रत्येक प्रक्रिया में एक लूप में foo [i] जैसे इंडेक्स के माध्यम से एक्सेस करें, जो इसे प्रक्रियाओं के साथ एक साझा मेमोरी एरिया/CoW semantics में डालता है, इस प्रकार यह स्मृति उपयोग को विस्फोट नहीं करता है (~ 3 पर रहता है गीगाबाइट्स)

4. हालांकि प्रदर्शन बेंचमार्क/ट्रेसिंग के अनुसार, ऐसा लगता है कि आवेदन समय के बड़े बहुमत को अब "अधिग्रहण" में खर्च किया गया है मोड ...

तो अगर वहाँ किसी भी तरह से मैं किसी भी तरह lockfree किसी प्रकार में इस सूची को बदल सकते हैं है मैं सोच रहा था/केवल पढ़ने के लिए इतना है कि मैं अधिग्रहण कदम का हिस्सा मदद करने के लिए तेजी लाने के साथ भाग कर सकते हैं और भी अधिक उपयोग करें।

संपादित करें 1: है सूची संरचना का एक उदाहरण यहाँ:

# Sample code for a rough idea of how the list is constructed 
sim = [] 
for root, dirs, files in os.walk(rootdir): 
    path = os.path.join(root, filename) 
    image= Image.open(path) 
    np_array = np.asarray(image) 
    sim.append((np_array, path)) 

# Roughly it would look something like say this below 
sim = List((np.array([[1, 2, 3], [4, 5, 6]], np.int32), "/foobar/com/what.something")) 

आगे से फिर यहाँ एप्लिकेशन

ncalls tottime percall cumtime percall filename:lineno(function) 
    65 2450.903 37.706 2450.903 37.706 {built-in method acquire} 
39320 0.481 0.000 0.481 0.000 {method 'read' of 'file' objects} 
    600 0.298 0.000 0.298 0.000 {posix.waitpid} 
    48 0.271 0.006 0.271 0.006 {posix.fork} 

संपादित 2 की रूपरेखा के शीर्ष कुछ लाइन उत्पादन है सिम सूची केवल पढ़ने के लिए है।

Answer 1

multiprocessing मॉड्यूल बिल्कुल वही प्रदान करता है जो आपको चाहिए: वैकल्पिक लॉकिंग के साथ एक साझा सरणी, अर्थात् multiprocessing.Array कक्षा। लॉकिंग अक्षम करने के लिए निर्माता को lock=False पास करें।

संपादित करें (अपना अपडेट खाता लेना): शुरुआती अपेक्षा से चीजें वास्तव में काफी अधिक शामिल हैं। आपकी सूची में सभी तत्वों का डेटा साझा स्मृति में बनाया जाना चाहिए। चाहे आप साझा मेमोरी में सूची (यानी वास्तविक डेटा के पॉइंटर्स) डाल दें, इससे कोई फर्क नहीं पड़ता क्योंकि यह सभी फाइलों के डेटा की तुलना में छोटा होना चाहिए। साझा स्मृति में फ़ाइल डाटा स्टोर करने के लिए,

shared_data = multiprocessing.sharedctypes.RawArray("c", data) 

जहां data डेटा आप फ़ाइल से पढ़ने का उपयोग करें। प्रक्रियाओं में से एक में एक NumPy सरणी के रूप में उपयोग करने के लिए,

numpy.frombuffer(shared_data, dtype="c") 

जो साझा किए गए डेटा के लिए एक NumPy सरणी दृश्य पैदा करेगा का उपयोग करें। इसी तरह, पथ नाम को साझा मेमोरी में डालने के लिए,

shared_path = multiprocessing.sharedctypes.RawArray("c", path) 

जहां पथ एक साधारण पायथन स्ट्रिंग है। अपनी प्रक्रियाओं में, आप shared_path.raw का उपयोग कर इसे पाइथन स्ट्रिंग के रूप में एक्सेस कर सकते हैं। अब अपनी सूची में (shared_data, shared_path) संलग्न करें। सूची अन्य प्रक्रियाओं में कॉपी हो जाएगी, लेकिन वास्तविक डेटा नहीं होगा।

प्रारंभ में मुझे वास्तविक सूची के लिए multiprocessing.Array का उपयोग करना था। यह पूरी तरह से संभव होगा और यह सुनिश्चित करेगा कि सूची भी स्वयं (यानी डेटा के पॉइंटर्स) साझा स्मृति में है। अब मुझे लगता है कि यह तब तक महत्वपूर्ण नहीं है जब तक कि वास्तविक डेटा साझा नहीं किया जाता है।