🍔 🍯 🤰🏼 फोर्थ VHDL प्रोसेसर 📖 👨🏿‍💼 😶

इस लेख में मैं आपको बताऊंगा कि वीएचडीएल पर प्रोसेसर कैसे लिखा जाए। बहुत कोड नहीं होगा (कम से कम मुझे उम्मीद है)। पूरा कोड जीथब पर पोस्ट किया गया है, और वहां आप लेखन के कई पुनरावृत्तियों को देख सकते हैं।

प्रोसेसर सॉफ्ट प्रोसेसर की श्रेणी में आता है।

आर्किटेक्चर

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

एक कमांड और ऑपरेंड का चयन
आदेश को निष्पादित करना और परिणाम को सहेजना

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

FPGA में, 18 बिट्स * 1024 कोशिकाओं के विन्यास के साथ एक ब्लॉक मेमोरी है। इस पर ध्यान केंद्रित करते हुए, मैं 9 बिट्स पर कमांड की बिट क्षमता का चयन करता हूं (2048 कमांड एक मेमोरी ब्लॉक में फिट होंगे)।
डेटा मेमोरी की क्षमता 32 बिट्स में "मानक" होनी चाहिए।
मैं बस का उपयोग करके परिधीय उपकरणों के साथ "संचार" को लागू करता हूं।

इस सारे अपमान की योजना निम्नलिखित में से लगभग पूरी हो जाएगी।

कमान प्रणाली

हमने वास्तुकला पर फैसला किया, अब "इस सब के साथ उतारने की कोशिश करें।" अब आपको कमांड सिस्टम के साथ आने की जरूरत है।
सभी प्रोसेसर कमांड को कई समूहों में विभाजित किया जा सकता है:

स्टैक पर शाब्दिक (संख्या) लोड हो रहा है
संक्रमण (सशर्त शाखा, सबरूटीन कॉल, रिटर्न)
डेटा मेमोरी तक पहुंच (पढ़ें और लिखें)
बस के लिए एक कॉल (अर्थ मेमोरी के लिए कॉल के समान है)।
ALU की टीमें।
अन्य टीमें

इसलिए, हमारे पास टीम की 9 श्रेणियां हैं, जिन्हें हमें पूरा करने की आवश्यकता है।

साहित्य डाउनलोड करें

कमांड की थोड़ी गहराई डेटा की थोड़ी गहराई से कम है, इसलिए आपको संख्याओं को लोड करने के लिए एक तंत्र के साथ आने की आवश्यकता है।

मैंने स्टैक पर शाब्दिक लोडिंग के लिए निम्न कमांड प्रारूप चुना:

स्मृती-विज्ञान	8	7	6	5	4	3	2	1	0
जगमगाता	1	जगमगाता

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

टीम ग्रुपिंग

मैंने आसान डिकोडिंग के लिए अन्य सभी कमांड को समूहों में तोड़ने का फैसला किया। हम जिस तरह से वे स्टैक को प्रभावित करते हैं, उसके आधार पर समूह बनाएंगे।

स्मृती-विज्ञान	8	7	6	5	4	3	2	1	0
जगमगाता	0	समूह				टीम

टीमों के समूह:

समूह	ढेर से लेता है	ढेर पर धक्का	उदाहरण
0	0	0	एनओपी
1	0	1	DEPTH
2	1	0	ड्रॉप
3	1	1	DUP @
4	2	0	, OUTPORT
5	2	1	अंकगणित (+, -,)

बदलाव:

स्मृती-विज्ञान	7	3
जेएमपी	2	0
कॉल	2	1
यदि	4	0
आरईटी	0	1

JMP और CALL कमांड, स्टैक से एड्रेस लेते हैं और उस पर जाते हैं (कॉल अतिरिक्त रूप से संबंधित स्टैक पर रिटर्न एड्रेस डालता है)।
आईएफ कमांड संक्रमण पता (स्टैक पर शीर्ष संख्या) और संक्रमण ध्वज (अगली संख्या) लेता है। यदि संकेत शून्य के बराबर है, तो पते पर संक्रमण किया जाता है।
आरईटी टीम रिटर्न स्टैक के साथ काम करती है, शीर्ष नंबर उठाती है और इसके ऊपर जाती है।
यदि कमांड एक संक्रमण नहीं है, तो कमांड काउंटर एक से बढ़ कर है।

कमांड टेबल

कमांड संकेतन का उपयोग करने के लिए, जो इस तरह दिखता है:
शब्द निष्पादन से पहले स्टैक स्थिति> - निष्पादन के बाद स्टैक स्थिति
शब्द>
स्टैक का शीर्ष दाईं ओर है, अर्थात 2 3 - 5 लिखने का मतलब है कि शब्द पूरा होने से पहले
स्टैक के शीर्ष पर नंबर 3 था, और इसके नीचे नंबर 2 था; इन नंबरों को करने के बाद
हटाए जाने के लिए निकले, और उनमें से 5 नंबर था।
एक उदाहरण:
DUP (a - aa)
DROP (ab - a)

कमांड का न्यूनतम सेट लें, जिसके साथ आप कम से कम कुछ कर सकते हैं।

ह \ ल	0	1	2	3	4	5	6	7	8	9
0	एनओपी	आरईटी
1	अस्थायी>	DEPTH	RDEPTH	DUP	से अधिक
2	जेएमपी	कॉल	ड्रॉप
3	@	INPORT	नहीं	SHL	SHR	SHRA
4	यदि	!	OUTPORT
5	जापानी	+	-	और	या	XOR	=	>	<	*

टीम	स्टैक संकेतन	विवरण
एनओपी		कोई ऑपरेशन नहीं। एक प्रोसेसर विलंबता
DEPTH	- डी	इस शब्द को निष्पादित करने से पहले डेटा स्टैक पर संख्याओं की संख्या को रोकना
RDEPTH	- डी	इस शब्द को निष्पादित करने से पहले रिटर्न स्टैक पर संख्याओं की संख्या को रोकना
DUP	ए - एए	डुप्लीकेट टॉप नंबर
से अधिक	एबी - एबीए	शीर्ष पर दूसरे नंबर के शीर्ष पर कॉपी करें
ड्रॉप	ए -	शीर्ष नंबर हटाएं
@	ए - डी	पता A पर डेटा मेमोरी पढ़ना
INPORT	ए - डी	पते पर बस से डेटा पढ़ना
नहीं	A - 0 \| -1 \|	लॉजिकल नॉट टॉप नंबर (0 को -1 से बदल दिया जाता है, किसी अन्य नंबर को 0 से बदल दिया जाता है)
SHL	ए - बी	शीर्ष नंबर 1 को बाईं ओर शिफ्ट करें
SHR	ए - बी	शीर्ष नंबर को दाईं ओर 1 अंक से स्थानांतरित करें
SHRA	ए - बी	दाईं ओर शीर्ष संख्या 1 अंक के अंकगणितीय बदलाव (संख्या का संकेत संरक्षित है)
!	DA -	डेटा स्मृति में पते पर डेटा डी लिखना
OUTPORT	DA -	पते पर डेटा डी को "बस" में लिखना (एक घड़ी चक्र के लिए आईओवर सिग्नल सेट किया जाएगा, परिधि को इस सिग्नल के उच्च स्तर के साथ अपना पता "पकड़ना" चाहिए)
जापानी	एबी - बी	दूसरे नंबर को स्टैक से ऊपर से हटाकर (नंबर TempReg रजिस्टर में जमा हो जाता है)
अस्थायी>	- ए	TempReg रजिस्टर सामग्री को पुनः प्राप्त करना
+	एबी - ए + बी	ढेर नंबर
-	एबी - एबी	शीर्ष नंबर से दूसरे नंबर से घटाव
और	एबी - ए और बी	बिटवाइज़ एंड ओवर हाइट्स
या	एबी - ए या बी	बिटवाइज़ या ऊपरी संख्याओं पर
XOR	एबी - एक एक्सोर बी	ऊपरी संख्याओं पर बिटवाइज़ XOR
=	एबी - 0 \| -1 \|	ऊपरी संख्याओं की समानता का सत्यापन। यदि संख्या समान हैं, तो स्टैक पर -1 छोड़ देता है, अन्यथा 0
>	एबी - 0 \| -1 \|	ऊपरी नंबरों की तुलना। यदि ए> बी, यह स्टैक पर -1 छोड़ देता है, अन्यथा 0. साइन को ध्यान में रखते हुए तुलना
<	एबी - 0 \| -1 \|	ऊपरी नंबरों की तुलना। यदि ए <बी, स्टैक पर -1 छोड़ देता है, अन्यथा 0. साइन को ध्यान में रखते हुए तुलना
*	एबी - ए * बी	ऊपरी संख्याओं का गुणन

आप एक प्रोसेसर घड़ी चक्र में स्टैक पर 1 नंबर लिख सकते हैं; किले में एक SWAP कमांड है जो स्टैक पर शीर्ष 2 नंबरों को स्वैप करता है। इसे लागू करने के लिए आपको 2 टीमों की आवश्यकता है। पहला कमांड, NIP (ab - b), शीर्ष से दूसरा नंबर "a" निकालता है और इसे एक अस्थायी रजिस्टर में संग्रहीत करता है, और दूसरा कमांड TEMP> (- a) इस नंबर को अस्थायी रजिस्टर से निकालता है और स्टैक के शीर्ष पर रखता है।

कोडिंग शुरू करना

स्मृति कार्यान्वयन।
कोड और डेटा मेमोरी टेम्पलेट के माध्यम से कार्यान्वित की जाती है:

process(clk) if rising_edge(clk) then if WeA = '1' then Ram(AddrA) <= DinA; end if; DoutA <= Ram(AddrA); DoutB <= Ram(AddrB); end if; end process;

राम एक संकेत है जो निम्नानुसार घोषित किया गया है:

 subtype RamSignal is std_logic_vector(RamWidth-1 downto 0); type TRam is array(0 to RamSize-1) of RamSignal; signal Ram: TRam;

मेमोरी को इस प्रकार आरंभीकृत किया जा सकता है:

 signal Ram: TRam := (0 => conv_std_logic_vector(0, RamWidth), 1 => conv_std_logic_vector(1, RamWidth), 2 => conv_std_logic_vector(2, RamWidth), -- ... others => (others => '0'));

एक समान टेम्पलेट के माध्यम से स्टैक कार्यान्वित किया गया

 process(clk) if rising_edge(clk) then if WeA = '1' then Stack(AddrA) <= DinA; DoutA <= DinA; else DoutA <= Stack(AddrA); end if; DoutB <= Stack(AddrB); end if; end process;

मेमोरी टेम्प्लेट से एकमात्र अंतर यह है कि यह आउटपुट में रिकॉर्ड किए गए मान को "आगे" करता है। पिछले टेम्पलेट के साथ, रिकॉर्ड किए गए मान को रिकॉर्डिंग, माप के बाद, अगले पर प्राप्त किया जाएगा।

सिंथेसाइज़र स्वचालित रूप से इन पैटर्नों को पहचानता है और संबंधित मेमोरी ब्लॉकों को उत्पन्न करता है। रिपोर्ट में यह दिखाई दे रहा है। उदाहरण के लिए, डेटा स्टैक के लिए, यह इस तरह दिखता है:

 ----------------------------------------------------------------------- | ram_type | Distributed | | ----------------------------------------------------------------------- | Port A | | aspect ratio | 16-word x 32-bit | | | clkA | connected to signal <clk> | rise | | weA | connected to signal <DSWeA> | high | | addrA | connected to signal <DSAddrA> | | | diA | connected to signal <DSDinA> | | | doA | connected to internal node | | ----------------------------------------------------------------------- | Port B | | aspect ratio | 16-word x 32-bit | | | addrB | connected to signal <DSAddrB> | | | doB | connected to internal node | | -----------------------------------------------------------------------

मुझे लगता है कि पूर्ण मेमोरी कार्यान्वयन कोड देने का कोई मतलब नहीं है, यह वास्तव में, बॉयलरप्लेट है।

प्रोसेसर का मुख्य चक्र - पहले घड़ी चक्र पर, टीम का नमूना लिया जाता है, दूसरे पर - निष्पादन। यह निर्धारित करने के लिए कि प्रोसेसर किस घड़ी पर है, एक लाने का संकेत है।

 process(clk) begin if rising_edge(clk) then if reset = '1' then --   ip <= (others => '0'); fetching <= '1'; else if fetching = '1' then fetching <= '0'; else fetching <= '1'; --  ,     end if; end if; end if; end process;

आदेश को डीकोडिंग और निष्पादित करने का सबसे सरल विकल्प सभी विकल्पों के लिए एक बड़ा "केस" है। लेखन में आसानी के लिए, इसे कई घटकों में विभाजित करना बेहतर है।
इस परियोजना में, मैंने इसे 3 भागों में तोड़ दिया:

एक मामला, जो डेटा स्टैक के पते को उत्पन्न करने और लिखने के संकेत को उत्पन्न करने के लिए जिम्मेदार होगा;
टीम के प्रदर्शन का मामला;
एक नया कमांड काउंटर (आईपी) बनाने का मामला।

 -- Data stack addr and we case conv_integer(cmd(8 downto 4)) is when 16 to 31 => -- LIT if PrevCmdIsLIT = '0' then DSAddrA <= DSAddrA + 1; end if; DSWeA <= '1'; when 0 => -- group 0; pop 0; push 0 null; when 1 => -- group 1; pop 0; push 1; DSAddrA <= DSAddrA + 1; DSWeA <= '1'; when 2 => -- group 2; pop 1; push 0; DSAddrA <= DSAddrA - 1; when 3 => -- group 3; pop 1; push 1; DSWeA <= '1'; when 4 => -- group 4; pop 2; push 0; DSAddrA <= DSAddrA - 2; when 5 => -- group 5; pop 2; push 1; DSAddrA <= DSAddrA - 1; DSWeA <= '1'; when others => null; end case;

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

अगला मामला टीम के निष्पादन के लिए जिम्मेदार होगा। यह डेटा स्टैक के लिए डेटा बनाता है (टॉटोलॉजी के लिए खेद है), ऑउटपोर्ट कमांड के लिए आईओआरवी सिग्नल आदि।

 -- Data stack value case conv_integer(cmd) is when 256 to 511 => -- LIT if PrevCmdIsLIT = '1' then DSDinA <= DSDoutA(DataWidth - 9 downto 0) & Cmd(7 downto 0); else DSDinA <= sxt(Cmd(7 downto 0), DataWidth); end if; when cmdPLUS => DSDinA <= DSDoutA + DSDoutB; when others => null; end case;

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

और आखिरी मामला कमांड काउंटर के लिए निम्नलिखित पते का गठन है:

 -- New ip and ret stack; case conv_integer(cmd) is when cmdJMP => -- jmp ip <= DSDoutA(ip'range); when cmdIF => -- if if conv_integer(DSDoutB) = 0 then ip <= DSDoutA(ip'range); else ip <= ip + 1; end if; when cmdCALL => -- call RSAddrA <= RSAddrA + 1; RSDinA <= ip + 1; RSWeA <= '1'; ip <= DSDoutA(ip'range); when cmdRET => -- ret RSAddrA <= RSAddrA - 1; ip <= RSDoutA(ip'range); when others => ip <= ip + 1; end case;

कार्यान्वित बुनियादी संक्रमण आदेश। संक्रमण का पता स्टैक से लिया जाता है।

परीक्षण

आगे बढ़ने से पहले, पहले से ही लिखित कोड का परीक्षण करना उचित है। मैंने एक TestBench बनाया, जिसमें मैंने पहले 100 ns में प्रोसेसर को केवल रीसेट सिग्नल दिया।

कोड मेमोरी को इस प्रकार शुरू किया गया था:

 signal CodeMemory: TCodeMemory := ( 0 => "000000000", -- lit tests 1 => "100000000", 2 => "100000001", 3 => "100000010", 4 => "000000000", 5 => "100001111", 6 => "000000000", 7 => "100010000", 8 => "100001000", 9 => conv_std_logic_vector(cmdPLUS, CodeWidth), 10 => conv_std_logic_vector(cmdPLUS, CodeWidth), 11 => conv_std_logic_vector(cmdDROP, CodeWidth), 12 => "100010011", 13 => conv_std_logic_vector(cmdJMP, CodeWidth), -- jmp to 19 14 => "100000010", 15 => "000000000", 16 => "100000010", 17 => conv_std_logic_vector(cmdPLUS, CodeWidth), 18 => conv_std_logic_vector(cmdRET, CodeWidth), -- ret 19 => "100001110", 20 => conv_std_logic_vector(cmdCALL, CodeWidth), -- call to 14 21 => "111111111", others => (others => '0') );

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

अनुकार परिणाम निम्न चित्रों (क्लिक करने योग्य) में दिखाया गया है:

पूरी परीक्षा:

संख्या लोडिंग परीक्षण:

पार्सिंग लोडिंग नंबर

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

कमांड # 1 स्टैक पर 0 नंबर लोड कर रहा है। निष्पादन चरण में 3 सिग्नल सेट किए जाते हैं: डेटा स्टैक का पता 1 से बढ़ जाता है, डेटा सेट होता है और लिखने की अनुमति सिग्नल सेट होता है।
अगले नमूने चक्र में, मान "0" का पता "1" स्टैक पर लिखा जाता है। मूल्य, भी, आउटपुट के लिए तुरंत "अग्रेषित" किया जाता है (ताकि अगला कमांड एक नए मूल्य पर संचालित हो)। राइट सक्षम सिग्नल हटा दिया गया है।

कमांड # 2 भी स्टैक पर एक संख्या लोड करने के लिए एक कमांड है। क्योंकि यह LIT कमांड का अनुसरण करता है, नए नंबर को स्टैक पर लोड नहीं किया जाएगा, लेकिन शीर्ष को संशोधित किया जाएगा। इसे 8 बिट्स बाईं ओर स्थानांतरित किया गया है, निचले हिस्से को कमांड से मान लिखा गया है (जो 0x01 है)।

कमांड # 3 कमांड # 2 के समान ऑपरेशन करता है। स्टैक पर संख्या, इसके ऑपरेशन के बाद 0x0102 के बराबर होती है।

निष्कर्ष

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

गिथब प्रोजेक्ट: github.com/whiteTigr/vhdl_cpu
सीपीयू कोड: github.com/whiteTigr/vhdl_cpu/blob/master/cpu.vhd
टेस्टबेंच कोड (हालाँकि इसमें व्यावहारिक रूप से कुछ भी नहीं है): github.com/whiteTigr/vhdl_cpu/blob/master/cpu_tb.vhd

फोर्थ VHDL प्रोसेसर