फोर्थ सीपीयू। यह क्या है (भाग 1)

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

हार्डवेयर सुविधाएँ

प्रोसेसर 16-बिट है, यह 32KB तक मेमोरी (नीचे 64Kb क्यों नहीं समझ सकता) को संबोधित कर सकता है। कोड और डेटा विभिन्न मेमोरी क्षेत्रों में हैं, इस प्रोसेसर पर चलने वाले प्रोग्राम का अधिकतम आकार भी 32Kb तक है।

आर्किटेक्चर स्टैक्ड है, प्रोसेसर में एक भी रजिस्टर नहीं है (जिसे स्पष्ट रूप से एक्सेस किया जा सकता है)। लेकिन इसमें दो स्टैक शामिल हैं:

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

दोनों ढेर उथले हैं, प्रत्येक में 33 तत्व। स्टैक, ज़ाहिर है, 16-बिट भी हैं।

वह सब है। I / O पोर्ट के बजाय, यह मेमोरी-मैप्ड I / O का उपयोग करने का प्रस्ताव है। ऐसा करने के लिए, मेमोरी के ऊपरी 16Kb को आरक्षित करने की सिफारिश की जाती है।

एमुलेटर

मैं गो पर वैचारिक रूप से सही कोड होने का दिखावा नहीं करता, लेकिन मैं उन लोगों के लिए भी इसे स्पष्ट करने की कोशिश करूंगा जो भाषा से परिचित नहीं हैं।

हम प्रोसेसर संरचना का वर्णन करते हैं:

 type J1Stack [33]uint16 type J1Cpu struct { pc uint16 r J1Stack s J1Stack rp int sp int mem []uint16 } 

कुल में, हमारे इम्यूलेटेड प्रोसेसर में एक पीसी इंस्ट्रक्शन काउंटर, डेटा स्टैक s, कॉल स्टैक आर, पॉइंटर्स इन स्टैक्स सपा और आरपी के सबसे ऊपर है, और आंतरिक मेमोरी (वैसे, मेमोरी भी केवल 16-बिट है, क्योंकि बाइट तक नहीं पहुंच सकते हैं) ।

हम J1Cpu प्रकार के लिए एक निर्माण कार्य लिखते हैं:

 func NewJ1Cpu(memSize int) (j1 *J1Cpu) { j1 = new(J1Cpu) j1.mem = make([]uint16, memSize) j1.sp, j1.rp = -1, -1 return j1 } 

कंस्ट्रक्टर में, हम संकेत के रूप में अधिक मेमोरी आवंटित करते हैं, और स्टैक को इनिशियलाइज़ करते हैं।

अनुदेश

प्रोसेसर के 5 निर्देश हैं:


वे निम्नानुसार काम करते हैं:
LIT X: स्टैक के शीर्ष पर मान X डालें। चूँकि 1 बिट इंगित करता है कि यह एक शाब्दिक है, केवल 15 बिट्स को मूल्य के लिए आवंटित किया गया है। इसलिए कोड और डेटा का 15-बिट पता।
JMP X: एड्रेस X पर जाएं
JZ X: यदि मान 0 स्टैक s के शीर्ष पर है, तो X को संबोधित करें
कॉल एक्स: स्टैक आर के शीर्ष पर रखा मूल्य पीसी + 1 (अगले निर्देश), और पता एक्स पर जाएं।
ALU: यह यहाँ थोड़ा अधिक जटिल है, मैं इसके बारे में नीचे बात करूँगा।

हम Exec पद्धति में इन निर्देशों के निष्पादन को कार्यान्वित करते हैं:

 const ( J1_OP = (7 << 13) J1_ARG = 0x1fff J1_JMP = (0 << 13) J1_JZ = (1 << 13) J1_CALL = (2 << 13) J1_ALU = (3 << 13) J1_LIT = (4 << 13) J1_LIT_MASK = 0x7fff ) func (j1 *J1Cpu) Exec(op uint16) { if op & J1_LIT != 0 { j1.sp++ j1.s[j1.sp] = op & J1_LIT_MASK j1.pc++ return } arg := op & J1_ARG switch op & J1_OP { case J1_JMP: j1.pc = arg case J1_JZ: if j1.s[j1.sp] == 0 { j1.pc = arg } j1.sp-- case J1_CALL: j1.rp++ j1.r[j1.rp] = j1.pc + 1 j1.pc = arg case J1_ALU: j1.execAlu(arg) } } 

पॉइंटर्स को स्टैक के शीर्ष पर बदलकर, मैं प्री-इंक्रीमेंट और पोस्ट-डीक्रीमेंट का उपयोग करता हूं। हालाँकि, गो में आप उन्हें C (स्टैक [++ sp] = x; ... x = stack [sp--]) के रूप में उपयोग नहीं कर सकते। क्योंकि आपको ऐसी चीजों को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता है।

यह निष्पादन विधि को लागू करने के लिए बना हुआ है - और यह हो चुका है!

जे 1 ए एल यू

यह सबसे शक्तिशाली निर्देश है। चलो पहले उन पात्रों पर निर्णय लेते हैं जो प्रोसेसर के लेखक उपयोग करते हैं।

टी - निर्देश के निष्पादन की शुरुआत में स्टैक के शीर्ष पर एक तत्व
N, निर्देश के आरंभ में T का अनुसरण करने वाला तत्व है
टी 'अंकगणितीय संचालन का परिणाम है
आर निर्देश के निष्पादन की शुरुआत में कॉल स्टैक के शीर्ष पर स्थित तत्व है
पीसी - प्रोसेसर निर्देश काउंटर मूल्य
[टी] - पते पर स्मृति तक अप्रत्यक्ष पहुंच टी

केवल 16 अंकगणितीय निर्देश हैं:
0: टी '= टी
1: टी '= एन
2: टी '= टी + एन
3: टी '= टी और एन
4: टी '= टी या एन
5: टी '= टी xor एन
6: टी '= ~ टी (बिटवाइस उलटा)
7: टी '= (टी == एन)
8: टी '= (एन <टी)
9: टी '= एन >> टी (टी बिट्स द्वारा सही बदलाव)
10: टी '= टी -1
11: टी '= आर
12: टी '= [टी]
13: टी '= एन << टी
14: टी '= गहराई (डेटा स्टैक गहराई)
15: टी '= (एन <टी), इस बार अहस्ताक्षरित तुलना

यहाँ इन कार्यों का कार्यान्वयन कैसा दिखेगा:

 func (j1 *J1Cpu) execAlu(op uint16) { var res, t, n, r uint16 if j1.sp >= 0 { t = j1.s[j1.sp] } if j1.sp > 0 { n = j1.s[j1.sp-1] } if j1.rp > 0 { r = j1.r[j1.rp-1] } j1.pc++ code := (op & (0xf << 8)) >> 8 switch code { case 0: res = t case 1: res = n case 2: res = t + n case 3: res = t & n case 4: res = t | n case 5: res = t ^ n case 6: res = ^t case 7: if n == t { res = 1 } case 8: if int16(n) < int16(t) { res = 1 } case 9: res = n >> t case 10: res = t - 1 case 11: res = j1.r[r] case 12: res = j1.mem[t] case 13: res = n << t case 14: res = uint16(j1.sp + 1) case 15: if n < t { res = 1 } } ds := op & 3 rs := (op & (3 << 2)) >> 2 if ds == 1 { j1.sp++ } if ds == 2 { j1.sp-- } if rs == 1 { j1.rp++ } if rs == 2 { j1.rp-- } if op&(1<<5) != 0 { println("N->[T]") j1.mem[t] = n } if op&(1<<6) != 0 { println("T->R") if j1.rp < 0 { panic("Call stack underrun") } j1.r[j1.rp] = t } if op&(1<<7) != 0 { println("T->N") if j1.sp > 0 { j1.s[j1.sp-1] = t } } if op&(1<<12) != 0 { println("R->PC") j1.pc = j1.r[r] } if j1.sp >= 0 { j1.s[j1.sp] = res } } 

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

उदाहरण के लिए, दो संख्याओं को जोड़ना तीन कमांड है
LIT 5 (स्टैक पर - 5)
LIT 7 (स्टैक पर - 5 7)
ALU OP = 2 (जोड़), DS = -1 (जो कि स्टैक पॉइंटर को 1. से जोड़ते और घटाते हैं। स्टैक पर, 12)।

दिलचस्प है, फ़ंक्शन से बाहर निकलने के लिए एक अलग निर्देश की आवश्यकता नहीं होती है। बस आखिरी निर्देश में झंडा "R-> पीसी" जोड़ा गया है। डेवलपर्स के अनुसार, यह कोड की मात्रा को लगभग 7% कम कर देता है।

और फोर्थ वास्तव में कहां है?

तथ्य यह है कि निर्देशों का यह सेट विशेष रूप से फोर्ट भाषा के लिए अनुकूलित है। इस भाषा के अधिकांश शब्द एकल निर्देश J1 के अनुरूप हैं। लेकिन J1 प्रोसेसर के संदर्भ में किले का एक संक्षिप्त परिचय अगले लेख में होगा, और अब मैं एमुलेटर के पूर्ण स्रोत कोड के लिए एक लिंक छोड़ दूंगा।
जो पहले से ही किले को जानता है - J1 के लिए क्रॉस-कंपाइलर यहां पाया जा सकता है (crossj1.fs)।