👩🏽‍🔧 👃🏽 🃏 मैनुअल: JIT से PyPy तक दुभाषिया लिखना 🍑 💡 🏪

इस लेख के सभी स्रोत कोड और उदाहरण यहां उपलब्ध हैं ।

पहली बार जब मैंने PyPy प्रोजेक्ट देखा, तो मुझे यह पता लगाने में थोड़ा समय लगा कि यह क्या है। इसमें दो चीजें शामिल हैं:

- प्रोग्रामिंग भाषाओं के दुभाषियों को लिखने के लिए उपकरणों का एक सेट;
- इस टूलकिट का उपयोग करके पायथन कार्यान्वयन।

ज्यादातर लोग शायद सोचते हैं कि PyPy सिर्फ दूसरा हिस्सा है, लेकिन यह गाइड Python दुभाषिया के बारे में नहीं है। यह आपकी भाषा की व्याख्या करने वाले के बारे में है।

मैंने इस गाइड को बेहतर तरीके से समझने के लिए लिया कि PyPy कैसे काम करता है और यह क्या है। यह माना जाता है कि आप PyPy के बारे में बहुत कम जानते हैं, इसलिए मैं शुरुआत से ही शुरुआत करूंगा।

PyPy क्या है?

मान लीजिए हम एक दुभाषिया लिखना चाहते हैं। इसमें एक स्रोत कोड पार्सर, एक बाईटेकोड निष्पादन पाश, और मानक पुस्तकालय में बहुत सारे कोड लिखना शामिल है।

एक पार्सर और कंपाइलर लिखना आमतौर पर बिल्कुल भी मजेदार नहीं होता है, इसलिए ऐसे उपकरण हैं जो आपके लिए एक पार्सर और कंपाइलर उत्पन्न करते हैं।

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

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

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

क्योंकि प्रभावी व्याख्याकारों को लिखने में कोई समस्या नहीं होनी चाहिए।

भाषा

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

< - पॉइंटर को पिछली सेल में ले जाएं।

> - पॉइंटर को अगली सेल में ले जाएं।

+ - वर्तमान सेल में एक नंबर की वृद्धि।

- - वर्तमान सेल में एक संख्या में कमी।

[ - यदि वर्तमान सेल में संख्या 0 है, तो संबंधित निर्देशों तक सभी निर्देशों को छोड़ दें]।

] - इसी निर्देश पर वापस जाएं [।

। - वर्तमान आउटपुट से मानक आउटपुट स्ट्रीम एक बाइट को आउटपुट।

, - मानक इनपुट स्ट्रीम से एक बाइट पढ़ें और वर्तमान सेल में डालें।

किसी भी अपरिचित पात्रों को नजरअंदाज किया जाना चाहिए।

कुछ इस भाषा को सीख सकते हैं, यह ब्रेनफक है।

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

पहला कदम

आइए नियमित पायथन में एक दुभाषिया लिखकर शुरू करें। यहाँ मुख्य रन लूप का एक स्केच है।

def mainloop(program): tape = Tape() pc = 0 while pc < len(program): code = program[pc] if code == ">": tape.advance() elif code == "<": tape.devance() elif code == "+": tape.inc() elif code == "-": tape.dec() elif code == ".": sys.stdout.write(chr(tape.get())) elif code == ",": tape.set(ord(sys.stdin.read(1))) elif code == "[" and value() == 0: # Skip forward to the matching ] elif code == "]" and value() != 0: # Skip back to the matching [ pc += 1

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

"[" और "]" ऑपरेटरों के कार्यान्वयन को छोड़ दिया गया है, उन्हें निर्देश काउंटर को मिलान ब्रैकेट की स्थिति में बदलना होगा।

और अब टेप वर्ग का कार्यान्वयन, जो पूर्णांक के एक टेप और एक सूचक को वर्तमान संख्या में संग्रहीत करता है।

 class Tape(object): def __init__(self): self.thetape = [0] self.position = 0 def get(self): return self.thetape[self.position] def set(self, val): self.thetape[self.position] = val def inc(self): self.thetape[self.position] += 1 def dec(self): self.thetape[self.position] -= 1 def advance(self): self.position += 1 if len(self.thetape) <= self.position: self.thetape.append(0) def devance(self): self.position -= 1

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

यदि कार्यक्रम में बहुत सारी टिप्पणियां हैं, तो उन्हें एक बाइट पढ़ा जाएगा, इसलिए अग्रिम में स्रोत कोड को पार्स करना बेहतर है। उसी समय, हम कोष्ठक के लिए एक शब्दकोश बनाएंगे ताकि आप इसमें जोड़ी कोष्ठक पा सकें।

 def parse(program): parsed = [] bracket_map = {} leftstack = [] pc = 0 for char in program: if char in ('[', ']', '<', '>', '+', '-', ',', '.'): parsed.append(char) if char == '[': leftstack.append(pc) elif char == ']': left = leftstack.pop() right = pc bracket_map[left] = right bracket_map[right] = left pc += 1 return "".join(parsed), bracket_map

यह फ़ंक्शन केवल भाषा आदेशों और जोड़ी कोष्ठक के शब्दकोश से एक स्ट्रिंग देता है।

यह इसे संयोजित करने के लिए बना हुआ है, और हमें एक वर्किंग ब्रेनफैक दुभाषिया मिलता है।

 def run(input): program, map = parse(input.read()) mainloop(program, map) if __name__ == "__main__": import sys run(open(sys.argv[1], 'r'))

स्क्वायर ब्रैकेट के कार्यान्वयन सहित दुभाषिया का पूरा कोड पहले उदाहरण में देखा जा सकता है। example1.py

अब आप पायथन में दुभाषिया चलाने की कोशिश कर सकते हैं ताकि यह सुनिश्चित हो सके कि यह काम करता है।

$ python example1.py 99bottles.b

PyPy प्रसारण

लेकिन हमारा लक्ष्य केवल एक विचार-विमर्श दुभाषिया लिखना नहीं था। PyPy को इस कोड से सुपरफास्ट निष्पादन योग्य फ़ाइल बनाने के लिए क्या करने की आवश्यकता है?

PyPy स्रोतों में, pypy / अनुवादक / लक्ष्य फ़ोल्डर में सरल उदाहरण हैं जो काम में आते हैं। आरंभ करने के लिए, Pyny के लिए एक सरल हैलो वर्ल्ड - targetnopstandalone.py पर एक नज़र डालें।

महत्वपूर्ण बात यह है कि मॉड्यूल में एक लक्ष्य फ़ंक्शन होता है जो एक प्रविष्टि बिंदु देता है। इस बिंदु से प्रसारण शुरू होता है।

 def run(fp): program_contents = "" while True: read = os.read(fp, 4096) if len(read) == 0: break program_contents += read os.close(fp) program, bm = parse(program_contents) mainloop(program, bm) def entry_point(argv): try: filename = argv[1] except IndexError: print "You must supply a filename" return 1 run(os.open(filename, os.O_RDONLY, 0777)) return 0 def target(*args): return entry_point, None if __name__ == "__main__": entry_point(sys.argv)

जब आप परिणामी निष्पादन योग्य चलाते हैं, तो entry_point फ़ंक्शन कमांड लाइन तर्क को स्वीकार करेगा।

RPython

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

उपरोक्त उदाहरण में, कई चीजों को बदलना पड़ा। अब आपको फ़ाइल ऑब्जेक्ट्स का उपयोग करने के बजाय os.open और os.read फ़ंक्शन के साथ निम्न-स्तरीय डिस्क्रिप्टर का उपयोग करना होगा। "।" और "," के कार्यान्वयन को भी थोड़ा संशोधित किया गया है। कोड को पचाने के लिए ये सभी बदलाव PyPy के लिए आवश्यक हैं।

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

पूर्ण कोड अब इस तरह दिखता है: example2.py

अनुवाद

यदि आपने पहले से ऐसा नहीं किया है, तो PyPy के नवीनतम संस्करण को bitbucket.org पर रिपॉजिटरी से मर्ज करें।

$ hg क्लोन bitbucket.org/pypy/pypy

चलाने की स्क्रिप्ट pypy / अनुवादक / लक्ष्य / Transl.py है। एक पैरामीटर के रूप में, यह मॉड्यूल को लेता है जिसका अनुवाद करने की आवश्यकता है।

$ python ./pypy/pypy/translator/goal/translate.py example2.py

तेज़ अनुवाद के लिए, आप पायथन के बजाय PyPy का उपयोग कर सकते हैं।

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

$ ./example2-c mandel.b

और पाइथन पर चलने वाले समान दुभाषिया के साथ गति की तुलना करें।

$ python example2.py mandel.b

तो, हमने RPython में एक दुभाषिया लिखा और PyPy टूलकिट का उपयोग करके इसका अनुवाद किया।

JIT जोड़ें

C में RPython का अनुवाद करना अच्छा है, लेकिन PyPy की मुख्य विशेषताओं में से एक रनटाइम कंपाइलर (JIT) उत्पन्न करने की क्षमता है। आपके दुभाषिया के काम करने के तरीके के बारे में कुछ संकेतों का उपयोग करते हुए, PyPy एक JIT कंपाइलर उत्पन्न करेगा जो व्याख्या किए गए ब्रेनफक कोड को मशीन कोड में अनुवाद करेगा।

ऐसा होने के लिए, PyPy को पता होना चाहिए कि कार्यक्रम निष्पादन चक्र कहां से शुरू होता है। यह आपको ट्रैक करने की अनुमति देता है कि कौन से निर्देशों को दिमाग पर लगाया गया है।

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

वापस दूसरे उदाहरण पर।

चार चर हमारे मुख्य रन लूप में उपयोग किए जाते हैं: पीसी, प्रोग्राम, ब्रैकेट_मैप और टेप। बेशक, पीसी, कार्यक्रम और ब्रैकेट_मैप हरे रंग के चर हैं, वे व्याख्या किए गए कार्यक्रम के निष्पादन को निर्धारित करते हैं। वैरिएबल टेप लाल है; यह तब बदल जाता है जब व्याख्या किए गए प्रोग्राम को निष्पादित किया जाता है।

आइए PyPy को यह डेटा बताते हैं। चलिए शुरू करते हैं JitDriver क्लास को इंपोर्ट करके और उसे इंस्टेंट करके।

 from pypy.rlib.jit import JitDriver jitdriver = JitDriver(greens=['pc', 'program', 'bracket_map'], reds=['tape'])

और इस लाइन को निष्पादन पाश की शुरुआत में जोड़ें:

 fjitdriver.jit_merge_point(pc=pc, tape=tape, program=program, bracket_map=bracket_map)

हमें JitPolicy को परिभाषित करने की भी आवश्यकता है।

 def jitpolicy(driver): from pypy.jit.codewriter.policy import JitPolicy return JitPolicy()

पूर्ण उदाहरण पाठ: example3.py

अब हम फिर से कोड का अनुवाद करेंगे, लेकिन ध्वज के साथ - गोद = जिट:

$ python ./pypy/pypy/translator/goal/translate.py --opt = jit example3.py

प्रसारण बहुत लंबा चलेगा, मेरी मशीन पर लगभग 8 मिनट, और परिणामी निष्पादन योग्य बहुत बड़ा होगा। प्रसारण समाप्त होने के बाद, हम फिर से भग्न पीढ़ी कार्यक्रम शुरू करेंगे। अंतर बहुत बड़ा है - पिछले संस्करण में 45 के मुकाबले लगभग 12 सेकंड!

जैसा कि आप देख सकते हैं, जेआईटी संकलक ने व्याख्या करने के बजाय वास्तव में मशीन कोड का उपयोग किया है। चित्र की पहली कुछ पंक्तियों को जल्दी से प्रदर्शित किया जाता है, फिर कार्यक्रम को त्वरित किया जाता है और शेष को और भी तेजी से प्रदर्शित किया जाता है।

ट्रेसर जेआईटी संकलक के बारे में थोड़ा

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

परिणामी लॉग को ऑप्टिमाइज़र को भेजा जाता है, जिसके परिणाम को मशीन कोड में बदल दिया जाता है। इस कोड का उपयोग लूप के बाद के रन के लिए किया जाता है।

परिणामी मशीन कोड केवल कुछ शर्तों के तहत सही है जिसके तहत इसे प्राप्त किया गया था। इसलिए, इसका उपयोग करने से पहले, इन स्थितियों की जांच की जाती है। यदि मशीन कोड के बजाय परीक्षण विफल हो जाता है, तो दुभाषिया फिर से शुरू होता है।

अधिक जानकारी विकिपीडिया पर पाई जा सकती है।

डिबगिंग और ट्रेस लॉग

क्या हम देख सकते हैं कि JIT क्या करता है?

चलो get_printable_location फ़ंक्शन को जोड़ते हैं, जिसका उपयोग डिबगिंग जानकारी को आउटपुट करने के लिए किया जाएगा।

 def get_location(pc, program, bracket_map): return "%s_%s_%s" % ( program[:pc], program[pc], program[pc+1:] ) jitdriver = JitDriver(greens=['pc', 'program', 'bracket_map'], reds=['tape'], get_printable_location=get_location)

यह फ़ंक्शन हरे रंग के चर लेता है और नियत तारीख को लौटाता है। हम ब्रेनफक कोड का उत्पादन करते हैं जिसमें वर्तमान निष्पादन योग्य स्टेटमेंट अंडरस्कोर से घिरा हुआ है।

उदाहरण कोड को example4.py में स्थानांतरित करें।

अब परीक्षण कार्यक्रम चलाएं (test.b ट्रेस लॉग के आउटपुट के साथ अक्षर "A" को लगभग 15 बार प्रिंट करता है)।

$ PYPYLOG = jit-log-opt: logfile ./example4-c test.b

लॉगफ़ाइल फ़ाइल में उत्पादित सभी निशानों के लॉग होते हैं और आपको यह देखने की अनुमति देता है कि मशीन कोड में कौन से निर्देश संकलित किए गए थे। फ़ाइल उपयोगी है कि यह आपको अनुकूलन के लिए अनावश्यक निर्देश या तरीके देखने की अनुमति देता है।

प्रत्येक ट्रेस इस तरह एक लाइन से शुरू होता है:
[3c091099e7a4a7] {jit-log-opt-loop

और इस पंक्ति के साथ समाप्त होता है:
[3c091099eae17d jit-log-opt-loop}

ट्रेस हेडर के तुरंत बाद एक सीरियल नंबर और ऑपरेशन की संख्या के साथ एक टिप्पणी है। मेरे मामले में, पहला ट्रेस इस तरह दिखता है।

  1: [3c167c92b9118f] {jit-log-opt-loop 2: # Loop 0 : loop with 26 ops 3: [p0, p1, i2, i3] 4: debug_merge_point('+<[>[_>_+<-]>.[<+>-]<<-]++++++++++.', 0) 5: debug_merge_point('+<[>[>_+_<-]>.[<+>-]<<-]++++++++++.', 0) 6: i4 = getarrayitem_gc(p1, i2, descr=<SignedArrayDescr>) 7: i6 = int_add(i4, 1) 8: setarrayitem_gc(p1, i2, i6, descr=<SignedArrayDescr>) 9: debug_merge_point('+<[>[>+_<_-]>.[<+>-]<<-]++++++++++.', 0) 10: debug_merge_point('+<[>[>+<_-_]>.[<+>-]<<-]++++++++++.', 0) 11: i7 = getarrayitem_gc(p1, i3, descr=<SignedArrayDescr>) 12: i9 = int_sub(i7, 1) 13: setarrayitem_gc(p1, i3, i9, descr=<SignedArrayDescr>) 14: debug_merge_point('+<[>[>+<-_]_>.[<+>-]<<-]++++++++++.', 0) 15: i10 = int_is_true(i9) 16: guard_true(i10, descr=<Guard2>) [p0] 17: i14 = call(ConstClass(ll_dict_lookup__dicttablePtr_Signed_Signed), ConstPtr(ptr12), 90, 90, descr=<SignedCallDescr>) 18: guard_no_exception(, descr=<Guard3>) [i14, p0] 19: i16 = int_and(i14, -9223372036854775808) 20: i17 = int_is_true(i16) 21: guard_false(i17, descr=<Guard4>) [i14, p0] 22: i19 = call(ConstClass(ll_get_value__dicttablePtr_Signed), ConstPtr(ptr12), i14, descr=<SignedCallDescr>) 23: guard_no_exception(, descr=<Guard5>) [i19, p0] 24: i21 = int_add(i19, 1) 25: i23 = int_lt(i21, 114) 26: guard_true(i23, descr=<Guard6>) [i21, p0] 27: guard_value(i21, 86, descr=<Guard7>) [i21, p0] 28: debug_merge_point('+<[>[_>_+<-]>.[<+>-]<<-]++++++++++.', 0) 29: jump(p0, p1, i2, i3, descr=<Loop0>) 30: [3c167c92bc6a15] jit-log-opt-loop}

मैंने debug_merge_point लाइनों को बहुत लंबा किया है।

यह कोड अनुभाग चार पैरामीटर लेता है: दो पॉइंटर्स टू ऑब्जेक्ट्स (p0 और p1) और दो नंबर (i2 और i3)।

पहला ऑपरेटर ">" 4 वीं पंक्ति पर शुरू होता है। यह निर्देशों के बिना चलता है और पूरी तरह से अनुकूलित दिखता है। यह चक्र हमेशा टेप के एक हिस्से के साथ काम करता है, और पॉइंटर से वर्तमान सेल स्थिर रहता है।

पांचवें से आठवें तक की लाइनें - ऑपरेटर "+"। सबसे पहले, सूचकांक i2 के साथ एक सरणी तत्व सूचक p1 (लाइन 6) से निकाला जाता है, इकाई को जोड़ा जाता है और i6 (लाइन 7) में संग्रहीत किया जाता है। परिणाम वापस सरणी (पंक्ति 8) में डाल दिया जाता है।

पंक्ति 9 "<" निर्देश से मेल खाती है, लेकिन इसे संचालन की भी आवश्यकता नहीं है। जाहिरा तौर पर - i2 और i3 टेप कोशिकाओं के लिए दो संकेत हैं, जिनकी गणना पहले से की जाती है। आप यह भी देख सकते हैं कि p1 एक कमांड लाइन है। यह स्पष्ट नहीं है कि p0 क्या है।

13 के माध्यम से लाइनें 10 "-" ऑपरेटर को निष्पादित करती हैं: वे सरणी के तत्व को निकालते हैं, घटाते हैं और इसे वापस डालते हैं।

14 वीं पंक्ति में हम ऑपरेटर "]" पर आते हैं। लाइनें 15 और 16 की जाँच करें यदि i9 सच है (यानी, शून्य के बराबर नहीं)। i9 वह मान है जिसे हमने एक-एक करके घटाया और टेप में डाला। लाइन 16 - चेक। यदि शर्त पूरी नहीं होती है, तो <Guard2> नामक एक फ़ंक्शन निष्पादित किया जाता है, जिसमें से एक पैरामीटर पारित किया जाता है, p0।

यदि चेक पास हो गया है, तो 23 के माध्यम से 17 लाइनों को ब्रैकेट_मैप शब्दकोश से जाने के लिए निर्देश का पता पुनः प्राप्त होता है। मुझे यकीन नहीं है कि ये लाइनें वास्तव में क्या करती हैं, लेकिन यह स्पष्ट है कि इनमें दो बाहरी कॉल और 3 चेक हैं। यह बहुत बेकार है, यह देखते हुए कि ब्रैकेट_मैप नहीं बदलता है और परिणाम वही पता होगा जिसके लिए आपको जाने की आवश्यकता है। लेकिन PyPy को इस बारे में पता नहीं है, लेकिन हम जानते हैं, इसलिए, हम इस जगह को ऑप्टिमाइज़ कर सकते हैं।

लाइन 24 ब्रैकेट_मैप से प्राप्त सूचक को बढ़ाता है। लाइनें 25 और 26 सत्यापित करती हैं कि यह कार्यक्रम की लंबाई से अधिक नहीं थी।

इसके अलावा, लाइन 27 एक अतिरिक्त जांच करता है कि सूचक कड़ाई से 86 के बराबर है। यह सुनिश्चित करने के लिए आवश्यक है कि चक्र की शुरुआत में कूदना चाहिए।

अंत में, चक्र 28 लाइन पर बंद हो जाता है, और लाइन 29 पर चक्र की शुरुआत में एक छलांग होती है जिसमें पैरामीटर p0, p1, i2, i3 होता है।

अनुकूलन

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

हमें अनुवादक को यह कहने के लिए एक और संकेत देने की आवश्यकता है कि एक शब्दकोश क्वेरी हमेशा समान शब्दकोश अनुक्रमित के लिए समान तत्वों को लौटाएगी।

ऐसा करने के लिए, हम डिक्शनरी कॉल को एक अलग फ़ंक्शन बनाएंगे और इसे pypy.rlib.jit.purefunction के साथ लपेटेंगे।

 @purefunction def get_matching_bracket(bracket_map, pc): return bracket_map[pc]

यह संस्करण example5.py में पाया जा सकता है।

इस उदाहरण को प्रसारित करें। मैंडलब्रॉट अब 12 के बजाय 6 सेकंड में पूरा हो गया है!

आइए नए ट्रेस लॉग पर एक नज़र डालें।

  1: [3c29fad7b792b0] {jit-log-opt-loop 2: # Loop 0 : loop with 15 ops 3: [p0, p1, i2, i3] 4: debug_merge_point('+<[>[_>_+<-]>.[<+>-]<<-]++++++++++.', 0) 5: debug_merge_point('+<[>[>_+_<-]>.[<+>-]<<-]++++++++++.', 0) 6: i4 = getarrayitem_gc(p1, i2, descr=<SignedArrayDescr>) 7: i6 = int_add(i4, 1) 8: setarrayitem_gc(p1, i2, i6, descr=<SignedArrayDescr>) 9: debug_merge_point('+<[>[>+_<_-]>.[<+>-]<<-]++++++++++.', 0) 10: debug_merge_point('+<[>[>+<_-_]>.[<+>-]<<-]++++++++++.', 0) 11: i7 = getarrayitem_gc(p1, i3, descr=<SignedArrayDescr>) 12: i9 = int_sub(i7, 1) 13: setarrayitem_gc(p1, i3, i9, descr=<SignedArrayDescr>) 14: debug_merge_point('+<[>[>+<-_]_>.[<+>-]<<-]++++++++++.', 0) 15: i10 = int_is_true(i9) 16: guard_true(i10, descr=<Guard2>) [p0] 17: debug_merge_point('+<[>[_>_+<-]>.[<+>-]<<-]++++++++++.', 0) 18: jump(p0, p1, i2, i3, descr=<Loop0>) 19: [3c29fad7ba32ec] jit-log-opt-loop}

बहुत बेहतर! अब प्रत्येक चक्र केवल एक जोड़, घटाव, सरणी से दो भार, सरणी में दो स्थान और बाहर निकलने की जाँच करता है। कोड को कमांड काउंटर पर किसी भी बदलाव की आवश्यकता नहीं है।

इस अनुकूलन का सुझाव मुझे अर्पण रीगो ने pypy-dev मेलिंग सूची में दिया था। कार्ल फ्रेडरिक में दुभाषिया अनुकूलन पर कई लेख हैं , जो उपयोगी भी साबित हुए हैं।

निष्कर्ष

मुझे आशा है कि इस लेख ने आपको आश्वस्त किया है कि PyPy न केवल एक तेज़ पायथन दुभाषिया है।

आप में से जो लोग PyPy JIT संकलक के बारे में अधिक जानना चाहते हैं, उनके लिए मैं Meta-Level: PyPy's Tracing JIT Compiler अनुरेखण लेख पढ़ने की सलाह देता हूं।

मैनुअल: JIT से PyPy तक दुभाषिया लिखना