प्रस्तावित लेख IEnumerable समानांतर तुल्यकालिक प्रसंस्करण समस्या के समाधान पर चर्चा करता है, और यह भी कि ऐसा कार्य कहां से आया है।

जैसा कि कई अन्य मामलों में, प्रस्तुत समाधान बहुत विशिष्ट आवश्यकताओं के साथ शुरू हुआ।

प्रस्तावना

आंतरिक परियोजनाओं में से एक में, डेटा सरणी पर 100+ स्लाइस के लिए एक पत्तेदार रिपोर्ट बनाने की आवश्यकता होती है, जिसके पढ़ने में 12 घंटे से अधिक समय लगता है। डेटा वॉल्यूम स्वयं भी बड़े हैं। लंबे समय तक पढ़ने और बड़ी मात्रा में डेटा का संयोजन (~ 1.5M tuples, जिनमें से प्रत्येक का वजन 50 एमबी तक है) कोड में दो सीमाओं का परिचय देता है: कई रीडिंग की चरम अवांछनीयता (कोई साप्ताहिक रिपोर्ट पर 50 दिन बिताने के लिए तैयार नहीं है) और, दुर्भाग्य से, तकनीकी रूप से संभव नहीं है पूरे नमूने को रैम में डाल दिया। विकास प्रक्रिया जो मुझसे पहले थी वह स्पष्ट रूप से पुनरावृत्त थी: जिस विधि से स्लाइस के लिए डेटा एकत्र किया गया था उसकी लंबाई लगभग 4000 लाइनें थी। मेरा काम इस कोड को समर्थित कोड में बदलना था।

आवश्यक शर्तें

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

विचार

इसलिए, मौजूदा स्थिति को तौलने के बाद, मैंने एक साधारण विचार तैयार किया: समानांतर थ्रेड्स में "ऑब्जेक्ट्स की स्ट्रीम" को संसाधित करने के लिए, जहां प्रत्येक स्लाइस की अपनी साफ-सुथरी विधि (या लैम्ब्डा) होती है जो एक अलग धागे में चलती है। चूंकि वस्तुओं की प्रारंभिक संख्या हमारे लिए अज्ञात है, इसलिए IEnumerable<T> इंटरफ़ेस "वस्तुओं की धारा" का प्रतिनिधित्व करने के लिए सबसे उपयुक्त था। यह केवल यह सुनिश्चित करने के लिए बना रहता है कि प्रत्येक थ्रेड का अपना IEnumerable<T> , और यह वही IEnumerable<T> (बस सिक्कों और चश्मे के बारे में समस्याओं की तरह)। जाहिर है, उपनाम "क्लोन" तुरंत ऐसी वस्तुओं से चिपक गया।

यह सुनिश्चित करना आवश्यक था कि प्रत्येक enumerable.Next() , ऑब्जेक्ट का एक भी उदाहरण पढ़ने के लिए थ्रेड्स में वितरित किया गया था। इस समाधान में एक ख़ासियत है (यह बल्कि एक ऋण है, लेकिन डरावना नहीं है): सभी धागे सबसे धीमे भाई की प्रतीक्षा करेंगे, अर्थात, पढ़ना तुल्यकालिक होगा। सच कहूं तो, मुझे वास्तव में उम्मीद थी कि किसी ने मेरे लिए यह पहले से ही लिखा है। उदाहरण के लिए, Microsoft ने अपने Parallel.Linq में ऐसा ही कुछ किया था। हालाँकि, उस समय ऐसा कुछ भी Google के लिए संभव नहीं था - संग्रह के समानांतर प्रसंस्करण से संबंधित सब कुछ एक संग्रह के कुछ हिस्सों (उदाहरण के लिए, Parallel.For() ) के समानांतर प्रसंस्करण से संबंधित था, लेकिन किसी भी तरह से - समस्या को हल नहीं किया जा रहा है। खैर, मुझे साइकिल से प्यार है, मेरे हाथ में एक फाइल है!

कोर समाधान

मेरे दिमाग में हमेशा यह समझ थी कि किसी भी इंटरफ़ेस के पीछे एक वस्तु छिपी होती है। इसलिए, एक संग्रह को क्लोन करने के लिए, आपको संभवतः वांछित इंटरफ़ेस के साथ किसी ऑब्जेक्ट को खोजने या आने की आवश्यकता है। और यहाँ यह आवश्यक नहीं है। C # भाषा ने लंबे समय तक अपने अनुयायियों को yield return और yield break सफलतापूर्वक प्रस्तुत किया। उनके आवेदन ने समाधान का आधार बनाया।

मुझे लगता है कि यह समझाने का कोई मतलब नहीं है कि कोड की प्रत्येक पंक्ति का जन्म कैसे हुआ। मैं विचार की व्याख्या करूंगा। आपका बहुत सारा डेटा प्राप्त करने के लिए, एक फैक्ट्री ऑब्जेक्ट GetClone() विधि के साथ बनाया जाता है, जो एक कॉल को एक विधि पर लौटाता है जो yield का उपयोग करता yield । पढ़ने के लिए सिंक्रनाइज़ होने के लिए और किसी को भी खोने के लिए, कारखाने अपने पाठकों को याद करते हैं और यह सुनिश्चित करते हैं कि मूल IEnumerable से अगली वस्तु का पठन केवल तब किया जाता है जब सभी पाठक पिछली वस्तु के एक उदाहरण के लिए अपना लिंक प्राप्त करते हैं। यह इस तथ्य से प्राप्त होता है कि प्रत्येक पाठक को दो वेटहैंडल सौंपे जाते हैं - "मैं पढ़ने के लिए तैयार हूं" और "मैंने पढ़ा है":

 private IEnumerable<T> _input; private IEnumerator<T> _inputEnumerator; private Dictionary<string, AutoResetEvent> _imReadyToRead; private Dictionary<string, AutoResetEvent> _iVeReadMyValue; private WaitHandle[] _ivAlreadyReadArray; private T _nextObject; private bool _hasCurrent; private bool _hasNext; ... private void GetNext() { if (!_hasCurrent) return; foreach (var ready in _imReadyToRead) ready.Value.Set(); do { WaitHandle.WaitAll(_ivAlreadyReadArray); //  ,   _hasNext = _inputEnumerator.MoveNext(); //      _nextObject = _inputEnumerator.Current; lock (_imReadyToRead) { if (!_hasNext) _hasCurrent = false; foreach (var ready in _imReadyToRead) ready.Value.Set(); //     .    } } while (_hasNext); } 

रीडिंग स्वयं IEnumerable से किया जाता है, जो ( GetCloneInstance ?) GetCloneInstance विधि द्वारा लौटाया गया है।

 private T GetCurrent(string subscriber) { T toReturn; _imReadyToRead[subscriber].WaitOne(); //   - ! toReturn = _nextObject; _iVeReadMyValue[subscriber].Set(); return toReturn; } private IEnumerable<T> GetCloneInstance(string key) { T res; do { res = GetCurrent(key); yield return res; } while (true); } 

तो, ऐसा लगता है, समानांतरकरण की समस्या हल हो गई थी। लेकिन पूर्व-तैयारी के दौरान, WaitAll() विधि की एक विशेषता का पता चला: यह एक समय में 64 से अधिक उदाहरणों के संचालन का समर्थन करता है। लेकिन मुझे १००+ पाठक चाहिए! कैसे हो? हां, सामान्य तौर पर, सरल। और मैंने क्लोन बनाना शुरू कर दिया। प्रत्येक 64 "ईमानदार" क्लोन में से, मैं शिकार को चुनता हूं कि मैं भविष्य में क्लोन करूंगा। बड़ी संख्या में पाठकों के लिए, मैं 2, 3, 4 आदि में क्लोन प्रकट कर सकता हूं। पीढ़ी! जैसा कि परीक्षण कवरेज द्वारा दिखाया गया है - काफी व्यवहार्य जीव। यह कुछ इस तरह दिखता है:

 private int _maxCloneOfOne = 64; //    private IEnumerable<T> _input; //    private Stack<ICloner<T>> cloners; // -,    64  private Dictionary<Guid, IEnumerable<T>> clones; //  private Stack<IEnumerable<T>> missMe; // ,     - ,    public IEnumerable<T> GetClone() { if (cloners.Count == 0) cloners.Push(new Cloner<T>(_input)); //    var isLast = clones.Count > 0 && clones.Count % (_maxCloneOfOne - 1) == 0; //    -      ICloner<T> cloner; var g = Guid.NewGuid(); IEnumerable<T> result; if (!isLast) { cloner = cloners.Peek(); //     -   } else { //    -    var lastCloneForCloner = cloners.Peek().GetClone(); missMe.Push(lastCloneForCloner); cloners.Push(cloner = new Cloner<T>(lastCloneForCloner)); g = Guid.NewGuid(); } result = cloner.GetClone(); clones.Add(g, result); return result; } 

अब बस इतना ही। जोड़ा गया आरंभीकरण कोड, सभी प्रकार की किनारे की स्थितियों के लिए जांच, ध्यान से तेरा-कैच में लपेटा गया। यह काम करता है।


अगर किसी को मेरा समाधान आवश्यक या कम से कम दिलचस्प लगता है, तो google.code पर पृष्ठ पर आपका स्वागत है। जो लोग नई सुविधाओं को सुधारने और खराब करने में भाग लेना चाहते हैं, उन्हें सभी दरवाजों की चाबियां मिलेंगी।