काहिरा का अन्वेषण करें: एक व्यावहारिक और कुशल ट्यूरिंग-पूर्ण स्टार्क-फ्रेंडली सीपीयू आर्किटेक्चर

काहिरा एक व्यावहारिक रूप से कुशल ट्यूरिंग-पूर्ण स्टार्क-अनुकूल सीपीयू वास्तुकला है। इस लेख में, हम निर्देश संरचना और राज्य संक्रमण के संदर्भ में काहिरा के सीपीयू वास्तुकला का परिचय देते हैं, और निर्देश के कुछ उदाहरण प्रदान करते हैं। निर्देश संरचना काहिरा सीपीयू द्वारा मूल रूप से समर्थित शब्द एक क्षेत्र तत्व है, जहां क्षेत्र विशेषता का कुछ निश्चित क्षेत्र है। P>2^63 प्रत्येक निर्देश में 1 या 2 शब्द होंगे। यदि तत्काल मान（[एपी] = "12345678"）निर्देश का पालन करता है, तो निर्देश 2 शब्दों पर कब्जा कर लेगा, और मान दूसरे शब्द में संग्रहीत किया जाएगा। प्रत्येक निर्देश के पहले शब्द में निम्नलिखित तत्व होते हैं: _dst[bit0…15]: गंतव्य पता ऑफ़सेट, प्रतिनिधि मान बंद -2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15}); [bit16…31]: op0 पता ऑफ़सेट, प्रतिनिधि मान off_op0 -2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15}); [bit32…47]: op1 पता ऑफ़सेट, प्रतिनिधि मान off_op1 -2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15}); [bit48]: गंतव्य पते का आधार रजिस्टर ऑफ़सेट, एपी या एफपी; dst reg [bit49]: op0 पता ऑफसेट, एपी या एफपी का आधार रजिस्टर; op0 reg [bit50…52]: op1 का पता, op1_src केस: 000 op1=m(op0+off_op1) केस: 001 op1=m(पीसी+off_op1) केस: 010 op1=m(fp+off_op1) केस: 100 op1=m(ap+off_op1) बिट53…54]: कम्प्यूटेशनल लॉजिक res_logic मामला: 00 रेस = op1 केस: 01 रेस = op0 + op1 केस: 10 रेस = op0 op1 [bit55…57]: पीसी का अद्यतन तर्क pc_update केस: 000 // आम अगला_पीसी = पीसी + निर्देश_आकार केस: 001 // पूर्ण कूद अगला_पीसी = रेस केस: 010 // रिलेटिव जंप अगला_पीसी = पीसी + रेस केस: 100 // सशर्त सापेक्ष कूद next_pc = pc + op1 (या इंस्ट्रक्शन_साइज़ अगर dst = 0) [bit58…59]: AP . का अद्यतन तर्क ap_update मामला: 00 next_ap = एपी (या एपी + 2 अगर ऑपोड = 1) केस: 01 next_ap = एपी + रेस केस: 10 next_ap = एपी + 1 [bit60…62]: ओपकोड प्रकार ओपकोड केस: 000 // jmp केस: 001 // कॉल केस: 010 // रेट केस: 100 // जोर दें राज्य संक्रमण टिप्पणी राज्य संक्रमण फ़ंक्शन एक सामान्य राज्य संक्रमण इकाई का प्रतिनिधित्व करता है (क्योंकि इसमें सभी निर्देश प्रकारों के प्रसंस्करण तर्क शामिल हैं), और एक गणना आमतौर पर कई लगातार निष्पादित निर्देशों में विघटित होती है। इसलिए, हमें चाहिए: निर्देश के पहले और बाद में निर्देश की सामग्री और राज्यों की वैधता सुनिश्चित करें (उदाहरण के लिए, एक निश्चित सीमा जांच और राज्य स्थिरता जांच पास करना) और सुनिश्चित करें कि निष्पादित निर्देश मान्य है। संक्रमण तर्क टिप्पणी यदि निर्देश निष्पादन से पहले और बाद की स्थिति सुसंगत है, तो राज्य के अद्यतन को निम्नलिखित तर्क के अनुसार निष्पादित किया जाना चाहिए: #Context: m(.). #Input state: (pc, ap, and fp). #Output state: (next_pc, next_ap, and next_fp). #Compute op0. If op0_reg == 0: // Judge the basic register of op0 according to the flag value, 0 is ap,1 is fp, and obtain the value of op0. op0 = m(ap + off_{op0}) else: op0 = m(fp + off_{op0}) #Compute op1 and instruction_size. switch op1_src: // Obtain the value of op1 case 0: instruction_size = 1 // op1 = m[[ap/fp + off_op0] +off_op1], with two-level imbedding at most. op1 = m(op0 + off_{op1}) case 1: instruction_size = 2 // There exist(s) immediate number(s). The instruction size is 2 words. op1 = m(pc + off_{op1})// #If off_{op1} = 1, we have op1 = immediate_value. // For example, [ap] = "12345678", op1 = "12345678" case 2: instruction_size = 1 // op1 = [fp + off_op1] op1 = m(fp + off_{op1}) case 4: instruction_size = 1 // op1 = [ap +off_op1] op1 = m(ap + off_{op1}) default: Undefined Behavior #Compute res. if pc_update == 4: // jnz if res_logic == 0 && opcode == 0 && ap_update != 1: // Assign && jump && advanced ap res = Unused // Under conditional jump, the values of res_logic, opcode and ap_update flags can only be as shown above.The res variable will not be used on this occasion. else: Undefined Behavior else if pc_update = 0, 1 or 2: switch res_logic: // The computational logic of res is: case 0: res = op1 case 1: res = op0 + op1 case 2: res = op0 * op1 default: Undefined Behavior else: Undefined Behavior # Compute dst. if dst_reg == 0: dst = m(ap + offdst) else: dst = m(fp + offdst) # Compute the new value of pc. switch pc_update: case 0: # The common case: [ap] = 1 next_pc = pc + instruction_size case 1: # Absolute jump: jmp abs 123 next_pc = res case 2: # Relative jump: jmp rel [ap - 1] next_pc = pc + res case 4: # Conditional relative jump (jnz): jmp rel [ap - 1] if [fp - 7] = 0 next_pc = if dst == 0: pc + instruction_size // If dst = 0, then pc conducts ordinary updates; otherwise, it is similar to Case 2. else: pc + op1 // Under this circumstance, res is Unused, so pc directly conducts + op1, instead of + res. default: Undefined Behavior # Compute new value of ap and fp based on the opcode. if opcode == 1: # "Call" instruction. assert op0 == pc + instruction_size assert dst == fp # Update fp. next_fp = ap + 2 // [ap] saves the current fp value, [ap + 1] saves the pc after the call instruction; when the ret instruction is executed, it is convenient to reset fp to [ap], and then continue to execute subsequent instructions. # Update ap. switch ap_update: case 0: next_ap = ap + 2 // [ap] saves the value of fp, and [ap+1] saves the instruction address after the call instruction; thus, ap increases by 2. default: Undefined Behavior else if opcode is one of 0, 2, 4: # Update ap. switch ap_update: case 0: next_ap = ap // [fp + 1] = 5 case 1: next_ap = ap + res // advanced ap [ap] += 123 case 2: next_ap = ap + 1 // normal [fp + 1] = [ap]; ap++ default: Undefined Behavior switch opcode: // Within the same function, the fp value remains unchanged. case 0: next_fp = fp case 2: # "ret" instruction. next_fp = dst // The ret instruction goes with the call instruction, and assert dst == fp. case 4: # "assert equal" instruction. assert res = dst next_fp = fp else: Undefined Behavior निर्देश सत्यापन जैसा कि चित्र 1 में दिखाया गया है, एक निर्देश में निम्नलिखित तत्व होते हैं: structure instruction := (off_dst : bitvec 16) (off_op0 : bitvec 16) (off_op1 : bitvec 16) (flags : bitvec 15) कहाँ पे: [bit0…15], [bit16…31], [bit32…47] रेंज में हैं off_dst off_op0 off_op1 -2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15}) लेकिन आकाशवाणी में, हम उन्हें निम्नलिखित रूप में परिवर्तित करते हैं: ऑफ∗ = ऑफ∗ + 2^15 (जहाँ * dst, op0 और op1 में से किसी एक का प्रतिनिधित्व करता है) तो का मान रेंज [0,2^16) होना चाहिए off∗ इसलिए, एक निर्देश की कोडिंग के लिए, हमारे पास है: निर्देश के 15-बिट फ़्लैग को NN की लंबाई वाले 15 वर्चुअल कॉलम आवंटित करने के बजाय, हम एक वर्चुअल कॉलम का उपयोग करते हैं। नोट: =∑_{j=i}^{14} 2j−i⋅fj ˜f_i 16N की लंबाई के साथ, जो निम्नलिखित आवश्यकताओं को पूरा करती है: ˜f_0 = ∑_{j=0}^{14} 2^{j-0}⋅f_j एक15-बिट मान है f_15 = 0 ˜f_i −2˜f_{i+1} = ∑_{j=i}^{14} (2^{j−i}⋅f_j) − 2⋅∑_{j=i+1}^{14} (2^{j−i−1}⋅fj) =∑_{j=1}^{14}(2j−i⋅fj) - ∑{j=i+1}^{14}(2j−i⋅ एफजे) = फाई इसलिए, समीकरण (1) को इस प्रकार लिखा जा सकता है: （2） इंस्ट = ˜off_dst + 2^16⋅˜off_op0 + 2^32⋅˜off_op1 + 2^48⋅˜f0 [0,263) क्योंकि परिमित क्षेत्र की विशेषता , एक निर्देश केवल एक मान्य फ़ील्ड तत्व के अनुरूप हो सकता है। P > 2^63 इसलिए, निर्देश के लिए ही, निम्नलिखित बाधाओं को पूरा किया जाना चाहिए: निर्देश： इंस्ट = ˜off_dst + 2^16⋅˜off_op0 + 2^32⋅˜off_op1 + 2^48⋅ f0 ˜ बिट： (˜f_i−2˜f_i +1)(˜f_i−2˜f_i+1 −1)=0 सभी के लिए i ∈ [0,15) अंतिम मान शून्य है: ˜f_15=0 वर्चुअल कॉलम [0,2^16), तो फिर [2^−15, 2^15) ऑफ़सेट रेंज में हैं: ˜off∗ ऑफ़∗ निर्देश उदाहरण समान दावा करें निम्नलिखित सिंटैक्स में जोर देने के बराबर निर्देश व्यक्त किया जा सकता है: = यह सुनिश्चित करता है कि सूत्र के दोनों पक्ष समान हैं; अन्यथा कार्यक्रम का निष्पादन अस्वीकार कर दिया जाएगा। समीकरण का बायां पक्ष अक्सर [ ] या [ ] से आता है, और दाईं ओर के कुछ संभावित रूप होते हैं (reg_0 और reg_1 या हो सकते हैं, ∘ जोड़ या गुणा हो सकता है, और imm हो सकता है कोई निश्चित फ़ील्ड तत्व): fp+off_dst ap+off_dst fp ap इम [reg1+offop1][reg1+offop1] [reg0+offop0]∘[reg1+offop1][reg0+offop0]∘[reg1+offop1] [reg0+offop0]∘imm[reg0+offop0]∘imm [[reg0+offop0+offop1][[reg0+offop0+offop1] विभाजन और घटाव को क्रमशः अलग-अलग ऑपरेंड ऑर्डर के साथ गुणा और जोड़ के रूप में व्यक्त किया जा सकता है। नोट 2: एक निर्देश को एक असाइनमेंट निर्देश के रूप में माना जा सकता है, जिसमें एक पक्ष का मूल्य ज्ञात होता है, और दूसरा पक्ष अज्ञात होता है। मुखर उदाहरण के लिए, [एपी] = 4 [एपी] = 4 को एक अभिकथन के रूप में माना जा सकता है कि [एपी] का मान 4 है, या संदर्भ के अनुसार एक असाइनमेंट सेटिंग [एपी] से 4 है। चित्र 4 प्रत्येक निर्देश के लिए "समान समान" निर्देशों और ध्वज मानों के कुछ उदाहरण दिखाता है: निर्देश की करें [fp + 1] = 5: व्याख्या जोर निर्देश => ओपकोड = 4 अगला_एपी = एपी => एपी_अपडेट = 00 = 0 नेक्स्ट_पीसी = पीसी + इंस्ट्रक्शन_साइज => पीसी_अपडेट = 000 = 0 op0 और op1 के लिए, कोई जोड़ या mul => res_logic(res) = 00 = 0 . नहीं है तत्काल मान मौजूद है => op1_src(op1) = 001 = 1 तत्काल मूल्य पता निर्देश देता है कि पते आसन्न हैं => off_op1 = 1 समीकरण के बाईं ओर [fp + 1] => dst_reg(dst) = 1 समीकरण के बाईं ओर [fp + 1] => off_dst = 1 op0_reg/ off_op0 => inital value(1/-1) // क्योंकि इस निर्देश में इन झंडे का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भर गया है। सशर्त और बिना शर्त कूद टिप्पणी निर्देश प्रोग्राम काउंटर के मूल्य को बदलने की अनुमति देता है। जेएमपी पीसी काहिरा सापेक्ष कूद का समर्थन करता है (इसका ऑपरेंड वर्तमान से ऑफसेट का प्रतिनिधित्व करता है और पूर्ण कूद - क्रमशः कीवर्ड और एब्स द्वारा दर्शाया जाता है। पीसीपीसी रिले निर्देश सशर्त हो सकता है। उदाहरण के लिए, जब मेमोरी यूनिट का मान 0 नहीं होता है, तो निर्देश चालू हो जाएगा। जेएमपी jmp निर्देश का सिंटैक्स इस प्रकार है: #Unconditional jumps. jmp abs jmp rel #Conditional jumps. jmp rel if ! चित्र 5 निर्देशों के कुछ उदाहरण और प्रत्येक निर्देश के संबंधित ध्वज मानों को दिखाता है: jmp निर्देश जेएमपी रिले [एपी +1] + [एफपी - 7] की करें: व्याख्या जेएमपी निर्देश => ओपकोड = 0 next_ap = एपी => ap_update = b00 = 0 अगला_पीसी = पीसी + रेस => पीसी_अपडेट = बी010 = 2 रेस = op0 + op1 => res_logic(res) = b01 = 1 op1: [fp - 7] => op1_src(op1) = b010 = 2 op1: [fp - 7] => off_op1 = -7 op0: [एपी + 1] => op0_src (op0) = 0 op0: [एपी + 1] => off_op0 = 1 dst_reg/ off_dst => inital value(1/-1) /// क्योंकि इस निर्देश में इन फ़्लैग्स का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भरा गया है। और करें कॉल करें रिट्वीट और निर्देश फ़ंक्शन स्टैक के कार्यान्वयन की अनुमति देते हैं। इंस्ट्रक्शन प्रोग्राम काउंटर ( ) और फ्रेम पॉइंटर ( ) रजिस्टर को अपडेट करता है। कॉल रिट कॉल पीसी एफपी प्रोग्राम काउंटर का अद्यतन निर्देश के समान है। का पिछला मान [ ] को लिखा जाता है, ताकि निर्देश कॉल से पहले के मान को मान पर रीसेट कर सके; इसी तरह, लौटा हुआ पीसीपीसी (कॉल निर्देश के बाद निर्देश का पता) [ ] को लिखा जाता है, ताकि निर्देश वापस कूद सके और कॉल निर्देश के बाद कोड का निष्पादन जारी रख सके। jmp fp ap ret fp एपी + 1 रिट चूंकि दो मेमोरी इकाइयां लिखी गई थीं, 2 से उन्नत और नए पर सेट है। एपी एफपी एपी निर्देशों का सिंटैक्स इस प्रकार है: call abs call rel ret चित्र 6 प्रत्येक निर्देश के अनुरूप और निर्देशों और ध्वज मानों के कुछ उदाहरण दिखाता है: कॉल रिट निर्देश कॉल एब्स [fp + 4] की करें: व्याख्या कॉल निर्देश => ओपकोड = 0 next_ap = एपी => ap_update = b00 = 0 next_pc = res => pc_update = b001 = 1 रेस = op1 => res_logic(res) = b00 = 0 op1: [fp + 4] => op1_src(op1) = b010 = 2 op1: [fp + 4] => off_op1 = 4 op0_reg/ off_op0 => inital value(0/1) /// क्योंकि इस निर्देश में इन झंडे का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भर गया है। dst_reg/ off_dst => inital value(0/0) /// क्योंकि इस निर्देश में इन फ़्लैग्स का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भरा गया है। आगे बढ़ना एपी निर्देश दिए गए ऑपरेंड द्वारा के मूल्य को बढ़ाता है। एपी += एपी टिप्पणी चित्र 7 उन्नत निर्देशों और प्रत्येक निर्देश के संबंधित ध्वज मानों के कुछ उदाहरण दिखाता है: एपी निर्देश एपी += 123 की करें: व्याख्या एपी निर्देश को आगे बढ़ाना => ओपकोड = 0 next_ap = एपी + रेस => ap_update = b01 = 1 नेक्स्ट_पीसी = पीसी + इंस्ट्रक्शन_साइज => पीसी_अपडेट = बी000 = 0 रेस = op1 => res_logic(res) = b00 = 0 op1 = 123 => op1_src(op1) = b001 = 1 op1 = 123 => off_op1 = 1 op0_reg/ off_op0 => inital value(1/-1) /// क्योंकि इस निर्देश में इन झंडे का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भर गया है। dst_reg/ off_dst => inital value(1/-1) /// क्योंकि इस निर्देश में इन फ़्लैग्स का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भरा गया है।