बहुत बड़ी टेक्स्ट फ़ाइल पर सीधे और कुशलता से कैसे पहुंचे?

Question

मेरे पास एक बहुत बड़ी टेक्स्ट फ़ाइलें (+ 10 जीबी) है जो मैं कुछ डेटा खनन तकनीकों के लिए पढ़ना चाहता हूं। ऐसा करने के लिए, मैं एमपीआई के साथ समांतर तकनीकी का उपयोग करता हूं, इसलिए कई प्रक्रियाएं एक ही फ़ाइल में एक साथ पहुंच सकती हैं।
असल में, मैं चाहता हूं कि प्रत्येक प्रक्रिया एन लाइनों की संख्या पढ़ें। चूंकि फ़ाइल संरचित नहीं है (फ़ील्ड की एक ही संख्या है लेकिन प्रत्येक फ़ील्ड में वर्णों की अलग-अलग संख्या हो सकती है), मैं फ़ाइल को पार्स करने के दायित्व में हूं और यह समानांतर नहीं है और इसमें काफी समय लगता है। क्या लाइन की एक विशिष्ट संख्या को सीधे पार्सिंग और लाइनों की गिनती करने का कोई तरीका है? आपकी मदद के लिए धन्यवाद।

Answer 1

यदि आपकी फ़ाइल अन्यथा अनुक्रमित नहीं है, तो कोई प्रत्यक्ष तरीका नहीं है।

इंडेक्सिंग यह इसके लायक हो सकता है (सभी पंक्ति समाप्ति को खोजने के लिए इसे स्कैन करें, और प्रत्येक पंक्ति के ऑफसेट या लाइनों के खंड को स्टोर करें)। यदि आपको फ़ाइल को कई बार संसाधित करने की आवश्यकता है, और यह नहीं बदलेगा, तो इसे अनुक्रमणित करने की लागत को आगे के रनों के लिए इंडेक्स का उपयोग करने में आसानी से ऑफसेट किया जा सकता है।

अन्यथा, यदि आपको बिल्कुल की सभी संख्याओं की आवश्यकता नहीं है, तो आप लाइनों/वस्तुओं की एक ही संख्या में, आप इसे केवल खराब कर सकते हैं।
किसी दिए गए ऑफसेट (1 जी कहें) की तलाश करें, और निकटतम लाइन विभाजक की तलाश करें। ऑफ़सेट 2 जी, आदि पर दोहराएं जब तक आपको पर्याप्त ब्रेक पॉइंट नहीं मिल जाते।

फिर आप अपने द्वारा पहचाने गए प्रत्येक भाग पर अपने समांतर कार्यों को बंद कर सकते हैं।

Answer 2

कोई नहीं है: जब तक कि आप अपने अज्ञात डेटा को नहीं पढ़ते, कोई भी नहीं जानता कि कितने नए लाइन वर्ण हैं। यह समस्या जटिलता ओ (एन) है जिसका अर्थ है कि कम से कम एक बार आपको पूरी फ़ाइल को पढ़ना होगा। फिर आप एक इंडेक्स टेबल बनाना चाहेंगे जहां आप रिकॉर्ड करते हैं कि आपकी फाइल में नए लाइन अक्षर कहां हैं: इसका उपयोग सभी प्रक्रियाओं द्वारा किया जा सकता है और fseek के साथ आप नाटकीय रूप से आगे की पहुंच बढ़ा सकते हैं।

Answer 3

यहाँ क्या उल्लेख किया गया है परे कुछ अन्य विकल्प है कि पूरी फ़ाइल को स्कैन की जरूरत नहीं होगी:

1. एक मास्टर प्रक्रिया है कि बच्चे प्रक्रियाओं है कि वास्तविक प्रसंस्करण करने के लिए पाइप/FIFOs के माध्यम से लाइनों को धक्का कर सकते हैं। यह थोड़ा धीमा हो सकता है लेकिन यदि उपप्रोसेस में बिताए गए 9 0% समय ग्रंथों की वास्तविक क्रंचिंग है, तो यह ठीक होना चाहिए।

2. एक बेवकूफ लेकिन प्रभावी चाल: कहें कि आपके पास एन प्रक्रियाएं हैं, और आप प्रत्येक प्रक्रिया को argv या कुछ "सीरियल नंबर" के रूप में बता सकते हैं। processor -serial_number [1|2|3...N] -num_procs N, वे सभी एक ही डेटा को पढ़ सकते हैं, लेकिन केवल 0 लाइनों को संसाधित करते हैं जिनमें lineno % num_procs == serial_number है। यह थोड़ा कम कुशल है क्योंकि वे सभी पूरे डेटा को पढ़ेंगे, लेकिन फिर, अगर वे केवल प्रत्येक एनथ लाइन पर काम करते हैं, और यही वह समय है जो आपको अधिकतर खाता है, तो आपको ठीक होना चाहिए।