सैंपलसॉर्ट: Difference between revisions

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


इस दोहराने वाले तुलना को टालने के लिए, सुपर स्केलर सैंपल सॉर्ट एक अतिरिक्त एरे <math>o</math> (जिसे ऑरेकल कहा जाता है) का उपयोग करता है जो प्रत्येक तत्व के एक बकेट से सम्बंधित होता है। पहले, एल्गोरिदम <math>o</math> के संदर्भ को निर्धारित करके यह निर्धारित करता है, फिर बकेट का आकार निर्धारित करके तत्वों को <math>o</math> द्वारा निर्धारित बकेट में रखता है। एरे <math>o</math> भी संग्रह स्थान में खर्च करता है, लेकिन क्योंकि इसमें केवल <math>n\cdot \log k</math> बिट संभावित होते हैं, इन खर्चों को इनपुट एरे के अनुपात में छोटा माना जा सकता है।
इस दोहराने वाले तुलना को टालने के लिए, सुपर स्केलर सैंपल सॉर्ट एक अतिरिक्त एरे <math>o</math> (जिसे ऑरेकल कहा जाता है) का उपयोग करता है जो प्रत्येक तत्व के एक बकेट से सम्बंधित होता है। पहले, एल्गोरिदम <math>o</math> के संदर्भ को निर्धारित करके यह निर्धारित करता है, फिर बकेट का आकार निर्धारित करके तत्वों को <math>o</math> द्वारा निर्धारित बकेट में रखता है। एरे <math>o</math> भी संग्रह स्थान में खर्च करता है, परंतु क्योंकि इसमें केवल <math>n\cdot \log k</math> बिट संभावित होते हैं, इन खर्चों को इनपुट एरे के अनुपात में छोटा माना जा सकता है।


[[Category:All articles with unsourced statements]]
[[Category:All articles with unsourced statements]]
Line 166: Line 166:


== इन-प्लेस सैंपलसॉर्ट ==
== इन-प्लेस सैंपलसॉर्ट ==
ऊपर दिखाए गए एफीसिएंट सैंपलसॉर्ट कार्यान्वयन का एक मुख्य नुकसान यह है कि यह यथास्थान नहीं है और सॉर्टिंग के दौरान इनपुट अनुक्रम के समान आकार की दूसरी अस्थायी ऐरे की आवश्यकता होती है। उदाहरण के लिए एफीसिएंट कार्यान्वयन क्विकसॉर्ट अपनी जगह पर हैं और इस प्रकार अधिक स्थान एफीसिएंट हैं। यद्यपि, सैंपलसॉर्ट को जगह-जगह भी लागू किया जा सकता है।<ref>{{cite journal|last1=Axtmann|first1=Michael|last2=Witt|first2=Sascha|last3=Ferizovic|first3=Daniel|last4=Sanders|first4=Peter|title=इन-प्लेस पैरेलल सुपर स्केलर सैंपलसॉर्ट (IPSSSSo)|journal=25th Annual European Symposium on Algorithms (ESA 2017)|date=2017|volume=87|issue=Leibniz International Proceedings in Informatics (LIPIcs)|pages=9:1–9:14|doi=10.4230/LIPIcs.ESA.2017.9}}</ref>
ऊपर दिखाए गए एफीसिएंट सैंपलसॉर्ट कार्यान्वयन की एक मुख्य हानि यह है कि यह इन-प्लेस नहीं है और सॉर्टिंग के समय इनपुट अनुक्रम के समान आकार की दूसरी अस्थायी ऐरे की आवश्यकता होती है। उदाहरण के लिए एफीसिएंट कार्यान्वयन क्विकसॉर्ट इन-प्लेस हैं और इस प्रकार अधिक प्लेस एफीसिएंट हैं। यद्यपि, सैंपलसॉर्ट को इन-प्लेस पर भी लागू किया जा सकता है।<ref>{{cite journal|last1=Axtmann|first1=Michael|last2=Witt|first2=Sascha|last3=Ferizovic|first3=Daniel|last4=Sanders|first4=Peter|title=इन-प्लेस पैरेलल सुपर स्केलर सैंपलसॉर्ट (IPSSSSo)|journal=25th Annual European Symposium on Algorithms (ESA 2017)|date=2017|volume=87|issue=Leibniz International Proceedings in Informatics (LIPIcs)|pages=9:1–9:14|doi=10.4230/LIPIcs.ESA.2017.9}}</ref>
 
इन-प्लेस एल्गोरिदम को चार चरणों में विभाजित किया गया है:
इन-प्लेस एल्गोरिदम को चार चरणों में विभाजित किया गया है:
# सैम्पलिंग जो उपरोक्त एफीसिएंट कार्यान्वयन में सैम्पलिंग के समतुल्य है।
# सैम्पलिंग जो उपरोक्त एफीसिएंट कार्यान्वयन में सैम्पलिंग के समतुल्य है।
# प्रत्येक प्रोसेसर पर स्थानीय वर्गीकरण, जो इनपुट को ब्लॉकों में समूहित करता है जैसे कि प्रत्येक ब्लॉक में सभी तत्व एक ही बकेट से संबंधित होते हैं, लेकिन बकेट आवश्यक रूप से मेमोरी में निरंतर नहीं होते हैं।
# प्रत्येक प्रोसेसर पर स्थानीय वर्गीकरण, जो इनपुट को ब्लॉकों में समूहित करता है जैसे कि प्रत्येक ब्लॉक में सभी तत्व एक ही बकेट से संबंधित होते हैं, परंतु बकेट आवश्यक रूप से मेमोरी में निरंतर नहीं होते हैं।
# ब्लॉक क्रमपरिवर्तन ब्लॉकों को विश्व स्तर पर सही क्रम में लाता है।
# ब्लॉक क्रमपरिवर्तन ब्लॉकों को विश्व स्तर पर सही क्रम में लाता है।
# क्लीनअप कुछ एलमेंट को बाल्टियों के किनारों पर ले जाता है।
# क्लीनअप कुछ एलमेंट को बकेट के साइड पर ले जाता है।


इस एल्गोरिदम का एक स्पष्ट नुकसान यह है कि यह प्रत्येक तत्व को दो बार पढ़ता और लिखता है, एक बार वर्गीकरण चरण में और एक बार ब्लॉक क्रमपरिवर्तन चरण में। यद्यपि, एल्गोरिथ्म अन्य अत्याधुनिक इन-प्लेस प्रतिस्पर्धियों की तुलना में तीन गुना तेज और अन्य अत्याधुनिक अनुक्रमिक प्रतिस्पर्धियों की तुलना में 1.5 गुना तेज प्रदर्शन करता है। जैसा कि सैम्पल के बारे में पहले ही ऊपर चर्चा की जा चुकी है, बाद के तीन चरणों के बारे में आगे विस्तार से बताया जाएगा।
इस एल्गोरिदम की एक स्पष्ट हानि यह है कि यह प्रत्येक तत्व को दो बार रीड और राइट करता है, एक बार वर्गीकरण चरण में और एक बार ब्लॉक क्रमपरिवर्तन चरण में। यद्यपि, एल्गोरिथ्म अन्य अत्याधुनिक इन-प्लेस प्रतिस्पर्धियों की तुलना में तीन गुना तेज और अन्य अत्याधुनिक अनुक्रमिक प्रतिस्पर्धियों की तुलना में 1.5 गुना तेज प्रदर्शन करता है। जैसा कि सैम्पल के बारे में पहले ही ऊपर चर्चा की जा चुकी है, बाद के तीन चरणों के बारे में आगे विस्तार से बताया जाएगा।


=== स्थानीय वर्गीकरण ===
=== स्थानीय वर्गीकरण ===

Revision as of 00:43, 2 August 2023

सैंपलसॉर्ट, डिवाइड एंड कंकर एल्गोरिथ्म पर आधारित एक सॉर्टिंग एल्गोरिथ्म है, जिसका उपयोग प्रायः पैरलेल प्रोसेसिंग सिस्टम में किया जाता है।[1] पारंपरिक डिवाइड एंड कंकर एल्गोरिथ्म, ऐरे को सब-इंटरवल या बकेट में विभाजित करता है। फिर इस बकेट को अलग-अलग क्रमबद्ध किया जाता है और एक साथ जोड़ दिया जाता है। यद्यपि, यदि ये ऐरे गैर-समान रूप से वितरित किए गए है, तो इन सॉर्टिंग एल्गोरिदम का प्रदर्शन अत्यधिक सीमा तक कम हो सकता है। सैंपलसॉर्ट इस समस्या का समाधान करने में सक्षम है जिसमें n-एलिमेंट सीक्वन्स के लिए एक s आकार का सैम्पल चुनकर तथा उस सैंपल को सॉर्ट करने के उपरांत p-1 < s एलेमेन्ट को परिणाम से चुनकर बकेट की रेंज निर्धारित की जाती है। ये एलमेंट (जिन्हें स्प्लिटर्स कहा जाता है) फिर ऐरे को लगभग p समान बकेट में विभाजित करते हैं।[2] सैंपलसॉर्ट का वर्णन 1970 के लेख, सैंपलसॉर्ट: ए सैंपलिंग अप्रोच टू मिनिमल स्टोरेज ट्री सॉर्टिंग में डब्ल्यू. डी. फ्रेज़र और ए. सी. मैककेलर द्वारा किया गया है।[3]

एल्गोरिथम

सैम्पल सॉर्ट क्विक सॉर्ट का सामान्यीकरण है। जहां क्विक सॉर्ट प्रत्येक चरण में अपने इनपुट को पिवट नामक एकल मान के आधार पर दो भागों में विभाजित करता है, सैंपलसॉर्ट इसके अतिरिक्त अपने इनपुट से एक बड़ा सैम्पल लेता है और अपने डेटा को तदनुसार बकेट में विभाजित करता है। क्विकसॉर्ट की तरह, यह फिर बकेट को पुनरावर्ती रूप से सॉर्ट करता है।

सैंपलसॉर्ट कार्यान्वयन तैयार करने के लिए, हमें p बकेट की संख्या तय करने की आवश्यकता होती है। जब यह किया जाता है, तो वास्तविक एल्गोरिदम तीन चरणों में संचालित होता है:[4]

  1. सैम्पल p−1 इनपुट से तत्व (स्प्लिटर्स)। सॉर्ट करें; आसन्न स्प्लिटर्स का प्रत्येक युग्म फिर एक बकेट को परिभाषित करता है।
  2. डेटा लूप करें, प्रत्येक तत्व को उपयुक्त बकेट में रखें। (इसका तात्पर्य यह हो सकता है: इसे मल्टीप्रोसेसर सिस्टम में एक प्रोसेसर को भेजें।)
  3. प्रत्येक बकेट को क्रमबद्ध करें.

पूर्ण क्रमबद्ध आउटपुट बकेट का संयोजन है।

एक सामान्य रणनीति है कि p को उपलब्ध प्रोसेसरों के संख्या के बराबर रखा जाता है। फिर डेटा प्रोसेसरों के बीच वितरित किया जाता है, जो कुछ अन्य, अनुक्रमशील, सॉर्टिंग एल्गोरिदम का उपयोग करके बकेटों को क्रमबद्ध करते हैं।

स्यूडोकोड

निम्नलिखित सूची उपर्युक्त तीन चरण वाले एल्गोरिदम को स्यूडोकोड के रूप में प्रदर्शित करती है और दिखाती है कि एल्गोरिदम सिद्धांत रूप में कैसे कार्य करता है।[5] निम्नांकित में, A अवर्गीकृत डेटा है, k ओवरसैंपलिंग कारक है, जिस पर बाद में चर्चा की गई है, और p स्प्लिटर्स की संख्या है.

function sampleSort(A[1..n], k, p)
    // if average bucket size is below a threshold switch to e.g. quicksort
    if n / k < threshold then smallSort(A) 
    /* Step 1 */
    select S = [S1, ..., S(p−1)k] randomly from // select samples
    sort S // sort sample
    [s0, s1, ..., sp−1, sp] <- [-∞, Sk, S2k, ..., S(p−1)k, ∞] // select splitters
    /* Step 2 */
    for each a in A
        find j such that sj−1 < a <= sj
        place a in bucket bj
    /* Step 3 and concatenation */
    return concatenate(sampleSort(b1), ..., sampleSort(bk))

स्यूडोकोड मूल फ्रेज़र और मैककेलर एल्गोरिदम से भिन्न है।[3] स्यूडोकोड में, सैंपलसॉर्ट को पुनरावर्ती रूप से कार्यवान्वित किया जाता है। फ़्रेज़र और मैककेलर ने केवल एक बार सैंपलसॉर्ट को कार्यान्वित किया और निम्नलिखित सभी पुनरावृत्तियों में क्विकसॉर्ट का उपयोग किया।

कम्प्लेक्सिटी

प्रोसेसर समानांतर कार्यान्वयन के लिए बिग ओ अंकन में दी गई कम्प्लेक्सिटी:

स्प्लिटर्स खोजें.

बकेट को भेजें.

सभी नोड्स को रीड करने के लिए
ब्रॉड्कैस्टिंग के लिए
सभी कीज के लिए बाइनरी सर्च हेतु
बकेट में 'की' भेजने के लिए

बकेट को क्रमबद्ध करें.

जहाँ अंतर्निहित अनुक्रमिक सॉर्टिंग पद्धति की कम्प्लेक्सिटी है।[1] प्रायः .

इस एल्गोरिथम द्वारा की गई तुलनाओं की संख्या, सूचना सैद्धांतिक इष्टतम के निकट पहुंचती है बड़े इनपुट अनुक्रमों के लिए. फ़्रेज़र और मैककेलर द्वारा किए गए प्रयोगों में, एल्गोरिदम को क्विकसॉर्ट की तुलना में 15% कम तुलना की आवश्यकता थी।

डेटा सैंपलिंग

डेटा का सैम्पल विभिन्न विधियों से लिया जा सकता है। कुछ विधियों में सम्मिलित हैं:

  1. समान दूरी वाले सैम्पल चुनें.
  2. यादृच्छिक विधि से चयनित सैम्पल चुनें.

ओवरसैंपलिंग

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

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

बकेट आकार अनुमान

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

यह सिद्ध करने के लिए हम सॉर्टिड सीक्वन्स के रूप में इनपुट लेते हैं। प्रोसेसर को से अधिक एलमेंट प्राप्त करने के लिए, लंबाई का एक ऐसा उपसूत्र होना आवश्यक है, जिसमें से अधिकतम S सैंपल्स चुने जाते हैं। ये तथ्य संभाव्यता का गठन करते हैं। इसे यादृच्छिक चर के रूप में निम्नलिखित रूप से दर्शाया जा सकता है:

के अपेक्षित मूल्य के लिए धारण करता है:
इसका उपयोग अनुमान लगाने के लिए किया जाएगा :
अब चेर्नॉफ़ बाध्य का उपयोग करके, इसे दिखाया जा सकता है:

कई इडेंटिकल 'की'(key)

कई इडेंटिकल 'की' के परिप्रेक्ष्य में, एल्गोरिदम कई पुनरावर्तन स्तरों से गुजरता है जहां अनुक्रमों को क्रमबद्ध किया जाता है, क्योंकि पूरे अनुक्रम में समान कुंजियाँ होती हैं। समानता बकेट प्रारंभ करके इसका प्रतिकार किया जा सकता है। पोल के बराबर एलमेंट को उनके संबंधित समानता बकेट में क्रमबद्ध किया जाता है, जिसे केवल एक अतिरिक्त सशर्त शाखा के साथ कार्यान्वित किया जा सकता है। समानता के बकेट आगे क्रमबद्ध नहीं हैं। यह काम करता है, क्योंकि कुंजियाँ अधिक से अधिक घटित होती हैं। इसमे समय के निर्णायक बनने की संभावना है।

पैरलेल सिस्टम में उपयोग

समानांतर सैम्पल सॉर्ट का उदाहरण प्रोसेसर और एक ओवरसैंपलिंग कारक .

सैंपलसॉर्ट का उपयोग प्रायः पैरलेल सिस्टम में किया जाता है, जिसमें वितरित कंप्यूटिंग जैसे कि बल्क सिंक्रोनस पैरलेल मशीने सम्मिलित हैं।[6][4][7] स्प्लिटर्स की परिवर्तनीय मात्रा (क्विकसॉर्ट में केवल एक पोल के विपरीत) के कारण, सैंपलसॉर्ट समानांतरीकरण और स्केलिंग के लिए बहुत उपयुक्त और सहज है। इसके अतिरिक्त सैंपलसॉर्ट भी उदाहरण के कार्यान्वयन की तुलना में अधिक कैश-एफीसिएंट है।

पैरललीकरण को प्रत्येक प्रोसेसर या नोड के लिए विभाजित करके अंगीकृत किया जाता है, जहां बकेटों की संख्या प्रोसेसरों की संख्या के बराबर होती है। सैंपलसॉर्ट पैरलल सिस्टम में प्रभावी होता है क्योंकि प्रत्येक प्रोसेसर को लगभग समान बकेट का आकार प्राप्त होता है। बकेट समानांतर सॉर्ट किए जाते हैं, इसलिए प्रोसेसर लगभग समान समय में सॉर्टिंग पूरा कर जाते हैं, इससे किसी प्रोसेसर को दूसरों के लिए रुकने की आवश्यकता नहीं होती है।

वितरित सिस्टम पर, स्प्लिटर्स का चयन एलमेंट को प्रत्येक प्रोसेसर पर लेकर किया जाता है, परिणामस्वरूप बने एलमेंट को वितरित सॉर्टिंग एल्गोरिदम के साथ सॉर्ट किया जाता है, हर -वां तत्व चुना जाता है और परिणाम को सभी प्रोसेसरों को ब्रॉडकास्ट किया जाता है। यह प्रोसेसरों पर एलमेंट को सॉर्ट करने के लिए का खर्च होता है, साथ ही चुने गए स्प्लिटर्स को प्रोसेसरों को वितरित करने के लिए का भी कॉस्ट होता है।

परिणामकारी स्प्लिटर्स के साथ, प्रत्येक प्रोसेसर अपने इनपुट डेटा को स्थानीय बकेट में रखता है। इसके लिए बाइनरी सर्च के साथ का समय लगता है। इसके बाद, स्थानीय बकेट्स प्रोसेसरों को पुनः वितरित किए जाते हैं। प्रोसेसर सभी अन्य प्रोसेसरों के स्थानीय बकेट्स को प्राप्त करता है और इन्हें स्थानीय रूप से सॉर्ट करता है। वितरण समय लेता है, जहां सबसे बड़े बकेट का आकार है। स्थानीय सॉर्ट का समय लेता है।

1990 के दशक में कनेक्शन मशीन सुपरकंप्यूटर पर किए गए प्रयोग ने दिखाया कि सैंपलसॉर्ट बड़े डेटासेट को सॉर्ट करने में विशेष रूप से अच्छा है, क्योंकि इसका इंटरप्रोसेसर संचार ओवरहेड कम होता है।[8] हाल के GPUs पर, इस एल्गोरिदम का प्रयोग उसके विकल्पों की तुलना में कम प्रभावी हो सकता है।[9]

सैम्पल सॉर्ट का एफीसिएंट कार्यान्वयन

सुपर स्केलर सैंपलसॉर्ट का एनिमेटेड उदाहरण। प्रत्येक चरण में, जिन संख्याओं की तुलना की जाती है उन्हें नीले रंग से चिह्नित किया जाता है और जो संख्याएं अन्यथा पढ़ी या लिखी जाती हैं उन्हें लाल रंग से चिह्नित किया जाता है।

जैसा कि ऊपर बताया गया है, सैंपलसॉर्ट एल्गोरिदम चयनित स्प्लिटर्स के अनुसार एलमेंट को विभाजित करता है। पेपर सुपर स्केलर सैंपल सॉर्ट में एक एफीसिएंट कार्यान्वयन रणनीति प्रस्तावित है।[5]पेपर में प्रस्तावित कार्यान्वयन एफीसिएंट कार्यान्वयन के लिए (इनपुट डेटा युक्त मूल ऐरे और एक अस्थायी) आकार की दो ऐरे का उपयोग करता है । इसलिए, कार्यान्वयन का यह संस्करण इन-प्लेस एल्गोरिदम नहीं है।

प्रत्येक रिकर्सन चरण में, डेटा को डिवाइड विधि से अन्य ऐरे में कॉपी किया जाता है। यदि डेटा अंतिम रिकर्सन चरण में अस्थायी ऐरे में है, तो डेटा को मूल ऐरे में वापस कॉपी किया जाता है।

बकेट का निर्धारण

किसी तुलना-आधारित सॉर्टिंग एल्गोरिदम में तुलना की संचार ऑपरेशन सबसे प्रदर्शन-मुख्य भाग होती है। सैंपलसॉर्ट में यह तत्व के लिए बकेट निर्धारित करने के लिए होती है। इसमें प्रत्येक तत्व के लिए समय लगता है।

सुपर स्केलर सैंपल सॉर्ट एक बैलन्स सर्च ट्री का उपयोग करता है जो स्वतः में एक एरे t में रखा गया होता है। रूट ट्री 0 पर रखा जाता है, का बाईं उत्तरधारी पर रखा जाता है और दाईं उत्तरधारी पर रखा जाता है। ट्री t को दिया गया है, एल्गोरिदम एलमेंट का बकेट नंबर j निम्नलिखित विधि से निर्धारित करता है (यहां स्वीकृति है कि का मूल्य 1 होगा यदि यह सत्य है और 0 होगा यदि यह सत्य नहीं है):

j := 1
repeat log2(p) times
    j := 2j + (a > tj)
j := jp + 1

बकेटों की संख्या k कंपाइल समय पर ज्ञात होती है, इसलिए कंपाइलर इस लूप को अनरोल कर सकता है। तुलना ऑपरेशन को प्रेडिकेटेड इंस्ट्रक्शन्स के साथ लागू किया जाता है। इससे ब्रांच मिसप्रिडिक्शन नहीं होती है, जो तुलना ऑपरेशन को काफी धीमा बना सकता है।

विभाजन

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

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

इन-प्लेस सैंपलसॉर्ट

ऊपर दिखाए गए एफीसिएंट सैंपलसॉर्ट कार्यान्वयन की एक मुख्य हानि यह है कि यह इन-प्लेस नहीं है और सॉर्टिंग के समय इनपुट अनुक्रम के समान आकार की दूसरी अस्थायी ऐरे की आवश्यकता होती है। उदाहरण के लिए एफीसिएंट कार्यान्वयन क्विकसॉर्ट इन-प्लेस हैं और इस प्रकार अधिक प्लेस एफीसिएंट हैं। यद्यपि, सैंपलसॉर्ट को इन-प्लेस पर भी लागू किया जा सकता है।[10]

इन-प्लेस एल्गोरिदम को चार चरणों में विभाजित किया गया है:

  1. सैम्पलिंग जो उपरोक्त एफीसिएंट कार्यान्वयन में सैम्पलिंग के समतुल्य है।
  2. प्रत्येक प्रोसेसर पर स्थानीय वर्गीकरण, जो इनपुट को ब्लॉकों में समूहित करता है जैसे कि प्रत्येक ब्लॉक में सभी तत्व एक ही बकेट से संबंधित होते हैं, परंतु बकेट आवश्यक रूप से मेमोरी में निरंतर नहीं होते हैं।
  3. ब्लॉक क्रमपरिवर्तन ब्लॉकों को विश्व स्तर पर सही क्रम में लाता है।
  4. क्लीनअप कुछ एलमेंट को बकेट के साइड पर ले जाता है।

इस एल्गोरिदम की एक स्पष्ट हानि यह है कि यह प्रत्येक तत्व को दो बार रीड और राइट करता है, एक बार वर्गीकरण चरण में और एक बार ब्लॉक क्रमपरिवर्तन चरण में। यद्यपि, एल्गोरिथ्म अन्य अत्याधुनिक इन-प्लेस प्रतिस्पर्धियों की तुलना में तीन गुना तेज और अन्य अत्याधुनिक अनुक्रमिक प्रतिस्पर्धियों की तुलना में 1.5 गुना तेज प्रदर्शन करता है। जैसा कि सैम्पल के बारे में पहले ही ऊपर चर्चा की जा चुकी है, बाद के तीन चरणों के बारे में आगे विस्तार से बताया जाएगा।

स्थानीय वर्गीकरण

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

ब्लॉक क्रमपरिवर्तन

सबसे पहले, एक उपसर्ग योग ऑपरेशन किया जाता है जो बकेट की सीमाओं की गणना करता है। यद्यपि, चूंकि इस चरण में केवल पूर्ण ब्लॉकों को स्थानांतरित किया जाता है, सीमाओं को ब्लॉक आकार के गुणक तक गोल किया जाता है और एक एकल अतिप्रवाह बफर आवंटित किया जाता है। ब्लॉक क्रमपरिवर्तन शुरू करने से पहले, कुछ खाली ब्लॉकों को इसकी बकेट के अंत में ले जाना पड़ सकता है। इसके बाद, एक सूचक लिखें बकेट की शुरुआत पर सेट है प्रत्येक बकेट के लिए उपऐरे और एक पठन सूचक बकेट में अंतिम गैर-खाली ब्लॉक पर सेट किया गया है प्रत्येक बकेट के लिए उपऐरे.

कार्य विवाद को सीमित करने के लिए, प्रत्येक प्रोसेसर को एक अलग प्राथमिक बकेट सौंपा गया है और दो स्वैप बफ़र्स जो प्रत्येक ब्लॉक को पकड़ सकते हैं। प्रत्येक चरण में, यदि दोनों स्वैप बफ़र खाली हैं, तो प्रोसेसर रीड पॉइंटर को कम कर देता है इसके प्राथमिक बकेट का और ब्लॉक को पढ़ता है और इसे अपने स्वैप बफ़र्स में से एक में रखता है। गंतव्य बकेट निर्धारित करने के बाद ब्लॉक के पहले तत्व को वर्गीकृत करके, यह राइट पॉइंटर को बढ़ाता है , पर ब्लॉक पढ़ता है दूसरे स्वैप बफ़र में और ब्लॉक को उसके गंतव्य बकेट में लिखता है। अगर , स्वैप बफ़र्स फिर से खाली हैं। अन्यथा स्वैप बफ़र्स में बचे ब्लॉक को उसके गंतव्य बकेट में डालना होगा।

यदि किसी प्रोसेसर की प्राथमिक बकेट की उपऐरे में सभी ब्लॉक सही बकेट में हैं, तो अगली बकेट को प्राथमिक बकेट के रूप में चुना जाता है। यदि कोई प्रोसेसर एक बार सभी बकेट को प्राथमिक बकेट के रूप में चुनता है, तो प्रोसेसर समाप्त हो जाता है।

सफ़ाई

चूँकि ब्लॉक क्रमपरिवर्तन चरण में केवल पूरे ब्लॉकों को स्थानांतरित किया गया था, कुछ तत्व अभी भी गलत तरीके से बकेट सीमाओं के आसपास रखे जा सकते हैं। चूंकि प्रत्येक तत्व के लिए ऐरे में पर्याप्त जगह होनी चाहिए, उन गलत तरीके से रखे गए एलमेंट को बाएं से दाएं खाली स्थानों पर ले जाया जा सकता है, अंत में ओवरफ्लो बफर पर विचार किया जा सकता है।

यह भी देखें

संदर्भ

  1. 1.0 1.1 "मानक टेम्पलेट अनुकूली समानांतर लाइब्रेरी का उपयोग करके नमूना सॉर्ट करें" (PDF) (Technical report). Texas A&M University.
  2. Grama, Ananth; Karypis, George; Kumar, Vipin (2003). "9.5 Bucket and Sample Sort". समानांतर कंप्यूटिंग का परिचय (2nd ed.). ISBN 0-201-64865-2. Archived from the original on 2016-12-13. Retrieved 2014-10-28.
  3. 3.0 3.1 Frazer, W. D.; McKellar, A. C. (1970-07-01). "Samplesort: A Sampling Approach to Minimal Storage Tree Sorting". Journal of the ACM. 17 (3): 496–507. doi:10.1145/321592.321600. S2CID 16958223.
  4. 4.0 4.1 Hill, Jonathan M. D.; McColl, Bill; Stefanescu, Dan C.; Goudreau, Mark W.; Lang, Kevin; Rao, Satish B.; Suel, Torsten; Tsantilas, Thanasis; Bisseling, Rob H. (1998). "BSPlib: The BSP Programming Library". Parallel Computing. 24 (14): 1947–1980. CiteSeerX 10.1.1.48.1862. doi:10.1016/S0167-8191(98)00093-3.
  5. 5.0 5.1 Sanders, Peter; Winkel, Sebastian (2004-09-14). "Super Scalar Sample Sort". Algorithms – ESA 2004. Lecture Notes in Computer Science. Vol. 3221. pp. 784–796. CiteSeerX 10.1.1.68.9881. doi:10.1007/978-3-540-30140-0_69. ISBN 978-3-540-23025-0.
  6. Gerbessiotis, Alexandros V.; Valiant, Leslie G. (1992). "डायरेक्ट बल्क-सिंक्रोनस समानांतर एल्गोरिदम". J. Parallel and Distributed Computing. 22: 22–251. CiteSeerX 10.1.1.51.9332.
  7. Hightower, William L.; Prins, Jan F.; Reif, John H. (1992). बड़ी समानांतर मशीनों पर यादृच्छिक छँटाई का कार्यान्वयन (PDF). ACM Symp. on Parallel Algorithms and Architectures.
  8. Blelloch, Guy E.; Leiserson, Charles E.; Maggs, Bruce M.; Plaxton, C. Gregory; Smith, Stephen J.; Zagha, Marco (1991). A Comparison of Sorting Algorithms for the Connection Machine CM-2. ACM Symp. on Parallel Algorithms and Architectures. CiteSeerX 10.1.1.131.1835.
  9. Satish, Nadathur; Harris, Mark; Garland, Michael. Designing Efficient Sorting Algorithms for Manycore GPUs. Proc. IEEE Int'l Parallel and Distributed Processing Symp. CiteSeerX 10.1.1.190.9846.
  10. Axtmann, Michael; Witt, Sascha; Ferizovic, Daniel; Sanders, Peter (2017). "इन-प्लेस पैरेलल सुपर स्केलर सैंपलसॉर्ट (IPSSSSo)". 25th Annual European Symposium on Algorithms (ESA 2017). 87 (Leibniz International Proceedings in Informatics (LIPIcs)): 9:1–9:14. doi:10.4230/LIPIcs.ESA.2017.9.


बाहरी संबंध

Frazer and McKellar's samplesort and derivatives:

Adapted for use on parallel computers: