हम अपने आप पर विश्वास करने और उड़ने के लिए monoids पर एक सुअर सिखाते हैं

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

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

$$

$$* \ * \ *$$

हास्केल एक विशेष आला के साथ एक अजीब भाषा है। इसके निर्माण और विकास का मुख्य लक्ष्य कार्यात्मक प्रोग्रामिंग के विचारों को व्यक्त करने और परीक्षण करने के लिए लिंगुआ फ्रेंका की आवश्यकता थी। यह इसकी सबसे महत्वपूर्ण विशेषताओं को सही ठहराता है: आलस्य, अत्यंत पवित्रता, उनके साथ प्रकार और जोड़तोड़ पर जोर। इसे रोजमर्रा के विकास के लिए नहीं, औद्योगिक प्रोग्रामिंग के लिए डिज़ाइन किया गया था, न कि व्यापक उपयोग के लिए। तथ्य यह है कि यह वास्तव में नेटवर्क उद्योग में बड़े पैमाने पर परियोजनाओं को बनाने के लिए उपयोग किया जाता है और डेटा प्रोसेसिंग में डेवलपर्स की सद्भावना है, अवधारणा का प्रमाण, यदि आप चाहें। लेकिन अब तक, हास्केल में लिखा गया सबसे महत्वपूर्ण, व्यापक रूप से इस्तेमाल किया जाने वाला और आश्चर्यजनक रूप से शक्तिशाली उत्पाद है ... ghc संकलक। और यह अपने उद्देश्य के दृष्टिकोण से पूरी तरह से उचित है - कंप्यूटर विज्ञान के क्षेत्र में अनुसंधान के लिए एक उपकरण होना। साइमन पायटन-जॉनसन द्वारा घोषित सिद्धांत: "हर कीमत पर सफलता से बचें" इस तरह के एक उपकरण बने रहने के लिए भाषा आवश्यक है। हास्केल अर्धचालक प्रौद्योगिकियों या नैनोमीटरों को विकसित करने वाले एक अनुसंधान केंद्र की प्रयोगशाला में एक बाँझ कक्ष की तरह है। इसमें काम करना बहुत असुविधाजनक है, और रोजमर्रा के अभ्यास के लिए यह कार्रवाई की स्वतंत्रता को भी प्रतिबंधित करता है, लेकिन इन असुविधाओं के बिना, प्रतिबंधों का पालन किए बिना, सूक्ष्म प्रभावों का निरीक्षण करना और अध्ययन करना संभव नहीं होगा जो बाद में औद्योगिक विकास का आधार बन जाएगा। इसी समय, उद्योग में बाँझपन की आवश्यकता केवल सबसे आवश्यक मात्रा में होगी, और इन प्रयोगों के परिणाम गैजेट के रूप में हमारी जेब में दिखाई देंगे। हम सितारों और आकाशगंगाओं का अध्ययन करते हैं क्योंकि हम उनसे प्रत्यक्ष लाभ प्राप्त करने की अपेक्षा नहीं करते हैं, बल्कि इसलिए कि इन अव्यावहारिक वस्तुओं के पैमाने पर, क्वांटम और सापेक्षतावादी प्रभाव अवलोकनीय और अध्ययन किए जाते हैं, इतना ही नहीं कि बाद में हम इस ज्ञान का उपयोग कुछ बहुत उपयोगितावादी विकसित करने के लिए कर सकते हैं। तो हास्केल अपनी "गलत" लाइनों के साथ, गणनाओं के अव्यावहारिक आलस्य, एक अत्यंत खड़ी इनपुट वक्र के साथ कुछ प्रकार के आविष्कार एल्गोरिदम की कठोरता, आखिरकार आपको घुटने या एक ऑपरेटिंग सिस्टम पर आसानी से स्मार्ट एप्लिकेशन बनाने की अनुमति नहीं देता है। हालांकि, लेंस, मोनाड्स, कॉम्बीनेटरियल पार्सिंग, मोनॉइड का व्यापक उपयोग, स्वचालित प्रमेय साबित करने के तरीके, घोषित कार्यात्मक पैकेज प्रबंधक, रैखिक और निर्भर प्रकार व्यावहारिक दुनिया के करीब पहुंच रहे हैं। यह पायथन, स्काला, कोटलिन, एफ #, जंग, और कई अन्य भाषाओं में कम बाँझ परिस्थितियों में आवेदन पाता है। लेकिन मैं कार्यात्मक प्रोग्रामिंग के सिद्धांतों को सिखाने के लिए इनमें से किसी भी अद्भुत भाषा का उपयोग नहीं करूंगा: मैं छात्र को प्रयोगशाला में ले जाऊंगा, यह दिखाऊंगा कि यह कैसे उज्ज्वल और स्वच्छ उदाहरणों में काम करता है, और फिर आप इन सिद्धांतों को कारखाने में देख सकते हैं एक बड़ी और समझ से बाहर, लेकिन बहुत तेज़ मशीन। किसी भी कीमत पर सफलता से बचना एक इलेक्ट्रॉन निर्माता को इलेक्ट्रॉन माइक्रोस्कोप में डालने के प्रयासों के खिलाफ संरक्षण है ताकि इसे लोकप्रिय बनाया जा सके। और प्रतियोगिताओं में जो भाषा कूलर है, हास्केल हमेशा सामान्य नामांकन के बाहर होगा।

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

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

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

हम आराम क्षेत्र छोड़ देते हैं

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

हम कार्यक्रम की प्रभावशीलता को एराटोस्थनीज की छलनी के भोले कार्यान्वयन पर परीक्षण करेंगे, जो शून्य और प्राइमरों को दर्शाते हुए, शून्य और लोगों के साथ मेमोरी (सरणी) को भरता है। हम javascript में प्रक्रियात्मक कोड को javascript :

 var memSize = 65536; var arr = []; for (var i = 0; i < memSize; i++) arr.push(0); function sieve() { var n = 2; while (n*n < memSize) { if (!arr[n]) { var k = n; while (k < memSize) { k+=n; arr[k] = 1; } } n++; } } 

एल्गोरिथ्म तुरंत थोड़ा अनुकूलित है। यह पहले से भरे हुए मेमोरी सेल्स के माध्यम से खराब चलना को समाप्त करता है। मेरा गणितज्ञ फरिश्ता PorosenokVM परियोजना में एक उदाहरण से वास्तव में भोले संस्करण के लिए सहमत नहीं था, क्योंकि इस अनुकूलन में स्टैक भाषा के केवल पांच निर्देश हैं। यहाँ बताया गया है कि एल्गोरिथ्म monopig कैसे monopig :

 sieve = push 2 <> while (dup <> dup <> mul <> push memSize <> lt) (dup <> get <> branch mempty fill <> inc) <> pop fill = dup <> dup <> add <> while (dup <> push memSize <> lt) (dup <> push 1 <> swap <> put <> exch <> add) <> pop 

और यहाँ है कि आप एक मुहावरेदार हास्केल पर इस एल्गोरिथ्म का एक समान कार्यान्वयन कैसे लिख सकते हैं, monopig में उसी प्रकार का उपयोग करके:

 sieve' :: Int -> Vector Int -> Vector Int sieve' km | k*k < memSize = sieve' (k+1) $ if m ! k == 0 then fill' k (2*k) m else m | otherwise = m fill' :: Int -> Int -> Vector Int -> Vector Int fill' knm | n < memSize = fill' k (n+k) $ m // [(n,1)] | otherwise = m 

यह इसके साथ काम करने के लिए Data.Vector प्रकार और उपकरणों का उपयोग करता है, जो हास्केल में रोजमर्रा के काम के लिए बहुत आम नहीं हैं। अभिव्यक्ति m ! k m ! k , वेक्टर m के k वें तत्व को लौटाता है, और m // [(n,1)] - संख्या n साथ तत्व को m // [(n,1)] सेट करता है। मैं इसे यहां लिख रहा हूं क्योंकि मुझे मदद के लिए उनके पास जाना था, हालांकि मैं हास्केल में काम करता हूं लगभग हर दिन। तथ्य यह है कि एक कार्यात्मक कार्यान्वयन में यादृच्छिक उपयोग के साथ संरचनाएं अक्षम हैं और इस कारण से अप्रकाशित हैं।

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

खौफ का साया !!! न केवल monopig धीमा करता है, इसलिए देशी संस्करण बहुत बेहतर नहीं है! हास्केल, ज़ाहिर है, शांत है, लेकिन इतना नहीं जितना कि एक ब्राउज़र में चल रहे प्रोग्राम से हीन है! जैसा कि कोच हमें सिखाते हैं, आप उस तरह से नहीं रह सकते, यह उस आरामदायक क्षेत्र को छोड़ने का समय है जो हास्केल हमें प्रदान करता है!

आलस्य पर काबू करें

चलो ठीक है। ऐसा करने के लिए, रन-टाइम आँकड़ों पर -rtsopts रखने के लिए -rtsopts ध्वज के साथ monopig पर एक कार्यक्रम संकलित करें और देखें कि हमें एक बार Eratosthenes चलनी चलाने की क्या आवश्यकता है:

 $ ghc -O -rtsopts ./Monopig4.hs [1 of 1] Compiling Main ( Monopig4.hs, Monopig4.o ) Linking Monopig4 ... $ ./Monopig4 -RTS -sstderr "Ok" 68,243,040,608 bytes allocated in the heap 6,471,530,040 bytes copied during GC 2,950,952 bytes maximum residency (30667 sample(s)) 42,264 bytes maximum slop 15 MB total memory in use (7 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 99408 colls, 0 par 2.758s 2.718s 0.0000s 0.0015s Gen 1 30667 colls, 0 par 57.654s 57.777s 0.0019s 0.0133s INIT time 0.000s ( 0.000s elapsed) MUT time 29.008s ( 29.111s elapsed) GC time 60.411s ( 60.495s elapsed) <--   ! EXIT time 0.000s ( 0.000s elapsed) Total time 89.423s ( 89.607s elapsed) %GC time 67.6% (67.5% elapsed) Alloc rate 2,352,591,525 bytes per MUT second Productivity 32.4% of total user, 32.4% of total elapsed 

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

इस बिंदु पर एक गणितज्ञ परी अपनी उंगली उठाती है और खुशी से इस तथ्य के बारे में बात करती है कि अलोंजो चर्च के समय से, एक प्रमेय है जो बताता है कि गणना की रणनीति उनके परिणाम को प्रभावित नहीं करती है, जिसका अर्थ है कि हम इसे दक्षता के कारणों से चुनने के लिए स्वतंत्र हैं। गणनाओं को सख्त में बदलना मुश्किल नहीं है - एक संकेत डालें ! स्टैक और मेमोरी के प्रकार की घोषणा में, और इस तरह इन क्षेत्रों को सख्त बनाते हैं।

 data VM a = VM { stack :: !Stack , status :: Maybe String , memory :: !Memory , journal :: !a } 

हम कुछ और नहीं बदलेंगे और तुरंत परिणाम की जांच करेंगे:

 $ ./Monopig41 +RTS -sstderr "Ok" 68,244,819,008 bytes allocated in the heap 7,386,896 bytes copied during GC 528,088 bytes maximum residency (2 sample(s)) 25,248 bytes maximum slop 16 MB total memory in use (14 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 129923 colls, 0 par 0.666s 0.654s 0.0000s 0.0001s Gen 1 2 colls, 0 par 0.001s 0.001s 0.0006s 0.0007s INIT time 0.000s ( 0.000s elapsed) MUT time 13.029s ( 13.048s elapsed) GC time 0.667s ( 0.655s elapsed) EXIT time 0.001s ( 0.001s elapsed) Total time 13.700s ( 13.704s elapsed) %GC time 4.9% (4.8% elapsed) Alloc rate 5,238,049,412 bytes per MUT second Productivity 95.1% of total user, 95.1% of total elapsed 

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

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

जीवन में परिवर्तन होने देना

Data.Vector प्रकार अच्छा है, लेकिन इसका उपयोग करते हुए, हम कंप्यूटिंग प्रक्रिया की शुद्धता को संरक्षित करने के नाम पर नकल करने में बहुत समय बिताते हैं। इसे Data.Vector.Unpacked प्रकार के साथ प्रतिस्थापित करने पर Data.Vector.Unpacked हम कम से कम संरचना की पैकेजिंग पर बचत करते हैं, लेकिन यह मूल रूप से तस्वीर को नहीं बदलता है। सही समाधान यह होगा कि मशीन की स्थिति से मेमोरी को हटा दें और क्लेस्ले श्रेणी का उपयोग करके बाहरी वेक्टर तक पहुंच प्रदान करें। एक ही समय में, शुद्ध वैक्टर के साथ, आप तथाकथित उत्परिवर्तनीय ( Data.Vector.Mutable ) वैक्टर Data.Vector.Mutable उपयोग कर सकते हैं। वैक्टर।

हम उपयुक्त मॉड्यूल को जोड़ेंगे और एक स्वच्छ कार्यात्मक कार्यक्रम में परस्पर डेटा से निपटने के तरीके के बारे में सोचेंगे।

 import Control.Monad.Primitive import qualified Data.Vector.Unboxed as V import qualified Data.Vector.Unboxed.Mutable as M 

इन गंदे प्रकारों को शुद्ध जनता से अलग माना जाता है। वे PrimMonad क्लास के PrimMonad में निहित हैं (इनमें ST या IO ), जहां स्वच्छ कार्यक्रम सावधानीपूर्वक कीमती चर्मपत्र पर क्रिस्टल कार्यात्मक भाषा में लिखे गए कार्यों के लिए निर्देश सम्मिलित करते हैं। इस प्रकार, इन अशुद्ध जानवरों का व्यवहार सख्ती से रूढ़िवादी परिदृश्यों द्वारा निर्धारित किया जाता है और खतरनाक नहीं है। हमारी मशीन के सभी प्रोग्राम मेमोरी का उपयोग नहीं करते हैं, इसलिए IO मोनाड में डूबने के लिए पूरी वास्तुकला को बर्बाद करने की आवश्यकता नहीं है। monopig भाषा के एक स्वच्छ सबसेट के साथ monopig हम चार निर्देश बनाएंगे जो स्मृति तक पहुंच प्रदान करते हैं, और केवल उनके पास खतरनाक क्षेत्र तक पहुंच होगी।

स्वच्छ मशीन का प्रकार छोटा होता जा रहा है:

 data VM a = VM { stack :: !Stack , status :: Maybe String , journal :: !a } 

कार्यक्रम डिजाइनर और कार्यक्रम स्वयं इस बदलाव को शायद ही नोटिस करेंगे, लेकिन उनके प्रकार बदल जाएंगे। इसके अलावा, हस्ताक्षर को सरल बनाने के लिए कई प्रकार के समानार्थक शब्दों को परिभाषित करना समझ में आता है।

 type Memory m = M.MVector (PrimState m) Int type Logger ma = Memory m -> Code -> VM a -> m (VM a) type Program' ma = Logger ma -> Memory m -> Program ma 

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

 geti :: PrimMonad m => Int -> Program' ma geti i = programM (GETI i) $ \mem -> \s -> if (0 <= i && i < memSize) then \vm -> do x <- M.unsafeRead mem i setStack (x:s) vm else err "index out of range" puti :: PrimMonad m => Int -> Program' ma puti i = programM (PUTI i) $ \mem -> \case (x:s) -> if (0 <= i && i < memSize) then \vm -> do M.unsafeWrite mem ix setStack s vm else err "index out of range" _ -> err "expected an element" get :: PrimMonad m => Program' ma get = programM (GET) $ \m -> \case (i:s) -> \vm -> do x <- M.read mi setStack (x:s) vm _ -> err "expected an element" put :: PrimMonad m => Program' ma put = programM (PUT) $ \m -> \case (i:x:s) -> \vm -> M.write mix >> setStack s vm _ -> err "expected two elemets" 

ऑप्टिमाइज़र डेमन ने स्मृति में अनुमेय सूचकांक मूल्यों की जांच करने पर तुरंत थोड़ा और बचाने की पेशकश की, क्योंकि puti और geti सूचकांकों को कार्यक्रम निर्माण के चरण में जाना जाता है और गलत मूल्यों को अग्रिम में समाप्त किया जा सकता है। डायनामिक रूप से परिभाषित इंडेक्स के लिए put और कमांड get हैं जो सुरक्षा की गारंटी नहीं देते हैं, और गणितज्ञ परी ने उन्हें खतरनाक कॉल करने की अनुमति नहीं दी।

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

आइए देखें कि हमने इन परिवर्तनों के साथ क्या खरीदा:

 $ ./Monopig5 +RTS -sstderr "Ok" 9,169,192,928 bytes allocated in the heap 2,006,680 bytes copied during GC 529,608 bytes maximum residency (2 sample(s)) 25,248 bytes maximum slop 2 MB total memory in use (0 MB lost due to fragmentation) Tot time (elapsed) Avg pause Max pause Gen 0 17693 colls, 0 par 0.094s 0.093s 0.0000s 0.0001s Gen 1 2 colls, 0 par 0.000s 0.000s 0.0002s 0.0003s INIT time 0.000s ( 0.000s elapsed) MUT time 7.228s ( 7.232s elapsed) GC time 0.094s ( 0.093s elapsed) EXIT time 0.000s ( 0.000s elapsed) Total time 7.325s ( 7.326s elapsed) %GC time 1.3% (1.3% elapsed) Alloc rate 1,268,570,828 bytes per MUT second Productivity 98.7% of total user, 98.7% of total elapsed 

यह पहले से ही प्रगति है! मेमोरी का उपयोग आठ गुना कम हो गया था, कार्यक्रम निष्पादन की गति 180 गुना बढ़ गई, और कचरा कलेक्टर लगभग पूरी तरह से काम के बिना बना रहा।

समाधान मोनोपिग सेंट दिखाई दिया । mut। , जो js पर मूल समाधान की तुलना में दस गुना धीमा है, लेकिन इसके अलावा, मस्कल वैक्टर का उपयोग करते हुए, हास्केल पर मूल समाधान। यहाँ उसका कोड है:

 fill' :: Int -> Int -> Memory IO -> IO (Memory IO) fill' knm | n > memSize-k = return m | otherwise = M.unsafeWrite mn 1 >> fill' k (n+k) m sieve' :: Int -> Memory IO -> IO (Memory IO) sieve' km | k*k < memSize = do x <- M.unsafeRead mk if x == 0 then fill' k (2*k) m >>= sieve' (k+1) else sieve' (k+1) m | otherwise = return m 

यह निम्नानुसार शुरू होता है

 main = do m <- M.replicate memSize 0 stimes 100 (sieve' 2 m >> return ()) print "Ok" 

और अब हास्केल अंत में दिखाता है कि वह एक खिलौना भाषा नहीं है। बस आपको इसे समझदारी से इस्तेमाल करने की जरूरत है। वैसे, उपरोक्त कोड इस तथ्य का उपयोग करता है कि प्रकार IO () कार्यक्रमों के अनुक्रमिक निष्पादन (>>) के संचालन के साथ एक stimes , और stimes की मदद से हमने परीक्षण समस्या की गणना को 100 बार दोहराया।

अब यह स्पष्ट है कि कार्यात्मक सरणियों के लिए इस तरह की नापसंद क्यों है और क्यों किसी को याद नहीं है कि उनके साथ कैसे काम करना है: जैसे ही एक हास्केल प्रोग्रामर को वास्तव में यादृच्छिक अभिगम संरचनाओं की आवश्यकता होती है, वह उत्परिवर्तनीय डेटा पर refocuses करता है और ST याO मोनोड्स में काम करता है।

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

वहां रुकना मत

अनावश्यक फ़ंक्शन कॉल को समाप्त करना और प्राग्मा {-# INLINE #-} का उपयोग करके सीधे उनके कोड को एम्बेड करना कार्यक्रम की उत्पादकता को थोड़ा बदलने में मदद करेगा। यह विधि पुनरावर्ती कार्यों के लिए अनुपयुक्त है, लेकिन बुनियादी घटकों और सेटर कार्यों के लिए महान है। यह परीक्षण कार्यक्रम के निष्पादन के समय को 25% कम कर देता है ( मोनोपिग51 देखें।)।

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

 program code f = programM code (const f) programM code f (Just logger) mem = Program . ([code],) . ActionM $ \vm -> case status vm of Nothing -> logger mem code =<< f mem (stack vm) vm _ -> return vm programM code f _ mem = Program . ([code],) . ActionM $ \vm -> case status vm of Nothing -> f mem (stack vm) vm _ -> return vm 

अब, निष्पादित कार्यों को स्पष्ट रूप से इंगित करना होगा कि none स्टब का उपयोग करके लॉगिंग की उपस्थिति या अनुपस्थिति को इंगित नहीं करना चाहिए, लेकिन Maybe (Logger ma) प्रकार Maybe (Logger ma) । यह काम क्यों करना चाहिए, क्योंकि यदि लॉगिंग है या नहीं, तो प्रोग्राम घटक निष्पादन से पहले "अंतिम समय पर" पता लगा लेंगे? क्या प्रोग्राम कंपोजिंग के चरण में अनावश्यक कोड को सीवन नहीं किया जाएगा? हास्केल एक आलसी भाषा है और यहां यह हमारे हाथों में खेलती है। यह निष्पादन से पहले है कि अंतिम कोड एक विशिष्ट कार्य के लिए अनुकूलित है। इस अनुकूलन ने कार्यक्रम के निष्पादन के समय को एक और 40% कम कर दिया (देखें मोनोपिग52 . hs )।

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

कुछ समस्याएं लॉगिंग के साथ रहती हैं। चरणों की संख्या की एक सरल गणना या स्टैक का उपयोग करना अच्छी तरह से काम करता है (हमने लॉग फ़ील्ड को सख्त बना दिया है), लेकिन उन्हें जोड़कर पहले से ही मेमोरी खाना शुरू कर दिया है, आपको seq का उपयोग करके किक के साथ गड़बड़ करना होगा, जो पहले से ही बहुत कष्टप्रद है। लेकिन मुझे बताइए, 14 बिलियन चरणों में कौन लॉग करेगा, यदि आप पहले सैकड़ों में कार्य को डीबग कर सकते हैं? इसलिए मैं अपना समय त्वरण के लिए तेज करने में नहीं बिताऊंगा।

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

$$

$$* \ * \ *$$

हास्केल इकोसिस्टम में कई Conduits और तेज़ समाधान होते हैं, जैसे कि Conduits या Pipes स्ट्रीम, उत्कृष्ट String रिप्लेसमेंट और attoparsec html जैसे एक्सएमएल निर्माता हैं, और attoparsec (∞) व्याकरण के लिए attoparsec विश्लेषण के लिए attoparsec पार्सर एक मानक है। यह सब सामान्य ऑपरेशन के लिए आवश्यक है। लेकिन इससे भी अधिक आवश्यक शोध इन फैसलों के लिए अग्रणी है। हास्केल रहा है और एक शोध उपकरण बना हुआ है जो आम जनता द्वारा आवश्यक विशिष्ट आवश्यकताओं को पूरा नहीं करता है। मैंने कमचटका में देखा कि कैसे एक तर्क पर Mi-4 हेलीकॉप्टर के इक्के पर माचिस की तीलियों को बंद कर दिया गया, और हवा में लटकते हुए एक पहिया के साथ लैंडिंग गियर को धकेल दिया। यह किया जा सकता है, और यह अच्छा है, लेकिन आवश्यक नहीं है।

लेकिन, फिर भी, यह अच्छा है !!