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

काहिरा एक व्यावहारिक रूप से कुशल ट्यूरिंग-पूर्ण स्टार्क-अनुकूल सीपीयू वास्तुकला है।

इस लेख में, हम निर्देश संरचना और राज्य संक्रमण के संदर्भ में काहिरा के सीपीयू वास्तुकला का परिचय देते हैं, और निर्देश के कुछ उदाहरण प्रदान करते हैं।

निर्देश संरचना

काहिरा सीपीयू द्वारा मूल रूप से समर्थित शब्द एक क्षेत्र तत्व है, जहां क्षेत्र विशेषता P>2^63 का कुछ निश्चित क्षेत्र है।

प्रत्येक निर्देश में 1 या 2 शब्द होंगे। यदि तत्काल मान（[एपी] = "12345678"）निर्देश का पालन करता है, तो निर्देश 2 शब्दों पर कब्जा कर लेगा, और मान दूसरे शब्द में संग्रहीत किया जाएगा। प्रत्येक निर्देश के पहले शब्द में निम्नलिखित तत्व होते हैं:

• बंद _dst[bit0…15]: गंतव्य पता ऑफ़सेट, प्रतिनिधि मान

  -2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15});

  
  

• off_op0 [bit16…31]: op0 पता ऑफ़सेट, प्रतिनिधि मान

-2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15});

• off_op1 [bit32…47]: op1 पता ऑफ़सेट, प्रतिनिधि मान

  -2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15});

  
  

• dst reg [bit48]: गंतव्य पते का आधार रजिस्टर ऑफ़सेट, एपी या एफपी;

  
  

• op0 reg [bit49]: op0 पता ऑफसेट, एपी या एफपी का आधार रजिस्टर;

  
  

• op1_src [bit50…52]: op1 का पता,

  
  

  • केस: 000
    op1=m(op0+off_op1)

    
    

  • केस: 001

    op1=m(पीसी+off_op1)

    
    

  • केस: 010
    op1=m(fp+off_op1)

    
    

  • केस: 100

    op1=m(ap+off_op1)

    
    

• res_logic बिट53…54]: कम्प्यूटेशनल लॉजिक

  
  

  • मामला: 00
    रेस = op1

    
    

  • केस: 01
    रेस = op0 + op1

    
    

  • केस: 10
    रेस = op0 op1

    
    

• pc_update [bit55…57]: पीसी का अद्यतन तर्क

  
  

  • केस: 000 // आम
    अगला_पीसी = पीसी + निर्देश_आकार

    
    

  • केस: 001 // पूर्ण कूद
    अगला_पीसी = रेस

    
    

  • केस: 010 // रिलेटिव जंप
    अगला_पीसी = पीसी + रेस

    
    

  • केस: 100 // सशर्त सापेक्ष कूद
    next_pc = pc + op1 (या इंस्ट्रक्शन_साइज़ अगर dst = 0)

    
    

• ap_update [bit58…59]: AP . का अद्यतन तर्क

  
  

  • मामला: 00
    next_ap = एपी (या एपी + 2 अगर ऑपोड = 1)

    
    

  • केस: 01
    next_ap = एपी + रेस

    
    

  • केस: 10
    next_ap = एपी + 1

    
    

• ओपकोड [bit60…62]: ओपकोड प्रकार

  
  

  • केस: 000 // jmp

    
    

  • केस: 001 // कॉल

    
    

  • केस: 010 // रेट

    
    

  • केस: 100 // जोर दें

राज्य संक्रमण टिप्पणी

राज्य संक्रमण फ़ंक्शन एक सामान्य राज्य संक्रमण इकाई का प्रतिनिधित्व करता है (क्योंकि इसमें सभी निर्देश प्रकारों के प्रसंस्करण तर्क शामिल हैं), और एक गणना आमतौर पर कई लगातार निष्पादित निर्देशों में विघटित होती है।

इसलिए, हमें चाहिए:

1. निर्देश के पहले और बाद में निर्देश की सामग्री और राज्यों की वैधता सुनिश्चित करें (उदाहरण के लिए, एक निश्चित सीमा जांच और राज्य स्थिरता जांच पास करना) और

   
   

2. सुनिश्चित करें कि निष्पादित निर्देश मान्य है।

संक्रमण तर्क टिप्पणी

यदि निर्देश निष्पादन से पहले और बाद की स्थिति सुसंगत है, तो राज्य के अद्यतन को निम्नलिखित तर्क के अनुसार निष्पादित किया जाना चाहिए:

 #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)

कहाँ पे:

off_dst [bit0…15], off_op0 [bit16…31], off_op1 [bit32…47] रेंज में हैं

-2^{15} + ∑_{i = 0}^{15} b_i । 2^i ∈ [-2^{15}, 2^{15})

लेकिन आकाशवाणी में, हम उन्हें निम्नलिखित रूप में परिवर्तित करते हैं:

ऑफ∗ = ऑफ∗ + 2^15

(जहाँ * dst, op0 और op1 में से किसी एक का प्रतिनिधित्व करता है)

तो off∗ का मान रेंज [0,2^16) होना चाहिए

इसलिए, एक निर्देश की कोडिंग के लिए, हमारे पास है:

नोट: निर्देश के 15-बिट फ़्लैग को NN की लंबाई वाले 15 वर्चुअल कॉलम आवंटित करने के बजाय, हम एक वर्चुअल कॉलम का उपयोग करते हैं।

˜f_i =∑_{j=i}^{14} 2j−i⋅fj

16N की लंबाई के साथ, जो निम्नलिखित आवश्यकताओं को पूरा करती है:

1. ˜f_0 = ∑_{j=0}^{14} 2^{j-0}⋅f_j एक15-बिट मान है

   
   

2. f_15 = 0

   
   

3. ˜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) को इस प्रकार लिखा जा सकता है:

इंस्ट = ˜off_dst + 2^16⋅˜off_op0 + 2^32⋅˜off_op1 + 2^48⋅˜f0 [0,263) （2）

क्योंकि परिमित क्षेत्र की विशेषता 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

ऑफ़सेट रेंज में हैं: वर्चुअल कॉलम ˜off∗ [0,2^16), तो फिर ऑफ़∗ [2^−15, 2^15)

निर्देश उदाहरण

समान दावा करें

निम्नलिखित सिंटैक्स में जोर देने के बराबर निर्देश व्यक्त किया जा सकता है:

<लेफ्ट_हैंडल_ऑप> = <राइट_हैंडल_ऑप>

यह सुनिश्चित करता है कि सूत्र के दोनों पक्ष समान हैं; अन्यथा कार्यक्रम का निष्पादन अस्वीकार कर दिया जाएगा।

समीकरण का बायां पक्ष अक्सर [ fp+off_dst ] या [ ap+off_dst ] से आता है, और दाईं ओर के कुछ संभावित रूप होते हैं (reg_0 और reg_1 fp या ap हो सकते हैं, ∘ जोड़ या गुणा हो सकता है, और imm हो सकता है कोई निश्चित फ़ील्ड तत्व):

• इम

  
  

• [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 <address> jmp rel <offset> #Conditional jumps. jmp rel <offset> if <op> !

चित्र 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 <address> call rel <offset> 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) /// क्योंकि इस निर्देश में इन फ़्लैग्स का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भरा गया है।

एपी आगे बढ़ना

निर्देश एपी += <op> दिए गए ऑपरेंड द्वारा एपी के मूल्य को बढ़ाता है।

टिप्पणी

चित्र 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) /// क्योंकि इस निर्देश में इन फ़्लैग्स का उपयोग नहीं किया गया है, डिफ़ॉल्ट मान भरा गया है।