🏮 🍶 🤟🏾 हम एचडीएल के बिना एफपीजीए के तहत लिखते हैं। उच्च-स्तरीय विकास साधनों की तुलना 🔦 🖖🏻 ⛰️

हाल ही में, FPGA निर्माताओं और तीसरे पक्ष की कंपनियों ने FPGAs के लिए सक्रिय रूप से विकास के तरीकों का विकास किया है जो उच्च-स्तरीय विकास साधनों का उपयोग करके पारंपरिक दृष्टिकोणों से भिन्न हैं।

एक FPGA डेवलपर के रूप में, मैं मुख्य उपकरण के रूप में वेरिलोग के हार्डवेयर विवरण भाषा ( HDL ) का उपयोग करता हूं, लेकिन नए तरीकों की बढ़ती लोकप्रियता ने मेरी बहुत रुचि पैदा की, इसलिए इस लेख में मैंने यह तय करने का फैसला किया कि क्या हो रहा था।

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

आपको FPGA के लिए उच्च-स्तरीय विकास उपकरण की आवश्यकता क्यों है?

परियोजना विकास को गति दें
- उच्च-स्तरीय भाषाओं में पहले से लिखे गए कोड के पुन: उपयोग के कारण;
- उच्च स्तरीय भाषाओं के सभी लाभों के उपयोग के माध्यम से, जब स्क्रैच से कोड लिखना;
- संकलन समय और कोड सत्यापन को कम करके।
सार्वभौमिक कोड बनाने की क्षमता जो किसी भी FPGA परिवार पर काम करेगी।
FPGAs के लिए विकास की सीमा को कम करें, उदाहरण के लिए, "घड़ी आवृत्ति" और अन्य निम्न-स्तरीय संस्थाओं की अवधारणाओं से बचना। FPGA के लिए एक डेवलपर के लिए कोड लिखने की क्षमता जो एचडीएल से परिचित नहीं है।

उच्च-स्तरीय विकास उपकरण कहां से आते हैं?

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

हर कोई अपने लक्ष्य को प्राप्त करने के लिए अपने तरीकों और उपकरणों का उपयोग करता है। एक परिपूर्ण और सुंदर दुनिया के संघर्ष में उत्साही अपनी पसंदीदा विकास भाषाओं का उपयोग करते हैं, जैसे कि पायथन या सी #। निगम, ग्राहक को खुश करने की कोशिश कर रहे हैं, अपने स्वयं के प्रस्ताव देते हैं या मौजूदा उपकरणों को अनुकूलित करते हैं। मैथवर्क्स एम-स्क्रिप्ट और सिमुलिंक मॉडल से एचडीएल कोड बनाने के लिए अपना एचडीएल कोडर उपकरण प्रदान करता है, जबकि इंटेल और एक्सलिनक्स आम सी / सी ++ के लिए संकलक प्रदान करते हैं।

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

Xilinx के बारे में क्या

इस लेख में, मैं Xilinx से HIL पर विचार नहीं करता, इंटेल और Xilinx के विभिन्न आर्किटेक्चर और CAD प्रणालियों के कारण, जो परिणामों की एक अस्पष्ट तुलना करना असंभव बनाता है। लेकिन मैं यह नोट करना चाहता हूं कि इंटेल एचएलएस की तरह एक्सिलिनक्स एचएलएस, एक सी / सी ++ संकलक प्रदान करता है और वे वैचारिक रूप से समान हैं।

आइए, मैथवर्क्स और इंटेल एचएलएस कंपाइलर से एचडीएल कोडर की तुलना करना शुरू करें, विभिन्न दृष्टिकोणों का उपयोग करके कई समस्याओं को हल किया है।

उच्च-स्तरीय विकास साधनों की तुलना

एक का परीक्षण करें। "दो गुणक और एक योजक"

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

मैथवर्क्स द्वारा एचडीएल कोडर

इस समस्या को हल करने के लिए, एम-स्क्रिप्ट इस प्रकार है:

function [out] = TwoMultAdd(a,b,c,d) out = (a*b)+(c*d); end

आइए देखें कि मैथवर्क्स हमें कोड को एचडीएल में बदलने के लिए क्या प्रदान करता है।

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

तो, पहली बात यह है कि इनपुट मानों का प्रकार और सीमा निर्धारित है। FPGA में कोई परिचित चार, इंट, फ्लोट, डबल नहीं हैं। संख्या की थोड़ी गहराई किसी भी हो सकती है, इसे चुनने के लिए तार्किक है, इनपुट मूल्यों की सीमा के आधार पर जिन्हें आप उपयोग करने की योजना बनाते हैं।

चित्र 1

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

चित्र 2

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

रन बटन दबाएं और निम्नलिखित कोड प्राप्त करें:

 `timescale 1 ns / 1 ns module TwoMultAdd_fixpt (a, b, c, d, out); input [7:0] a; // ufix8 input [7:0] b; // ufix8 input [7:0] c; // ufix8 input [7:0] d; // ufix8 output [16:0] out; // ufix17 wire [15:0] TwoMultAdd_fixpt_mul_temp; // ufix16 wire [16:0] TwoMultAdd_fixpt_2; // ufix17 wire [15:0] TwoMultAdd_fixpt_mul_temp_1; // ufix16 wire [16:0] TwoMultAdd_fixpt_3; // ufix17 //HDL code generation from MATLAB function: TwoMultAdd_fixpt //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // % // Generated by MATLAB 9.2 and Fixed-Point Designer 5.4 % // % //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% assign TwoMultAdd_fixpt_mul_temp = a * b; assign TwoMultAdd_fixpt_2 = {1'b0, TwoMultAdd_fixpt_mul_temp}; assign TwoMultAdd_fixpt_mul_temp_1 = c * d; assign TwoMultAdd_fixpt_3 = {1'b0, TwoMultAdd_fixpt_mul_temp_1}; assign out = TwoMultAdd_fixpt_2 + TwoMultAdd_fixpt_3; endmodule // TwoMultAdd_fixpt

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

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

इस तरह के कोड से क्वार्टस का संश्लेषण होता है।

चित्र 3

कोई समस्या नहीं, सब कुछ योजना के अनुसार था।

FPGA में हम सिंक्रोनस सर्किट को लागू करते हैं, और फिर भी मैं रजिस्टरों को देखना चाहूंगा। एचडीएल-कोडर रजिस्टरों को रखने के लिए एक तंत्र प्रदान करता है, लेकिन उन्हें कहां रखा जाए, यह डेवलपर के लिए है। हम मल्टीप्लायरों के इनपुट पर रजिस्टरों को एडलर के सामने मल्टीप्लायरों के आउटपुट पर या योजक के आउटपुट पर रख सकते हैं।

उदाहरणों को संश्लेषित करने के लिए, मैंने FPGA चक्रवात V परिवार को चुना, जहाँ विशेष डीएसपी ब्लॉकों को अंतर्निर्मित जोड़ियों और गुणकों में अंकगणितीय कार्यों को लागू करने के लिए उपयोग किया जाता है। डीएसपी ब्लॉक इस तरह दिखता है:

चित्र 4

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

यह निम्नलिखित कोड का पता लगाता है:

 `timescale 1 ns / 1 ns module TwoMultAdd_fixpt (clk, reset, clke_ena_i, a, b, c, d, clke_ena_o, out); input clk; input reset; input clke_ena_i; input [7:0] a; // ufix8 input [7:0] b; // ufix8 input [7:0] c; // ufix8 input [7:0] d; // ufix8 output clke_ena_o; output [16:0] out; // ufix17 wire enb; wire [16:0] out_1; // ufix17 wire [15:0] TwoMultAdd_fixpt_mul_temp; // ufix16 wire [16:0] TwoMultAdd_fixpt_2; // ufix17 wire [15:0] TwoMultAdd_fixpt_mul_temp_1; // ufix16 wire [16:0] TwoMultAdd_fixpt_3; // ufix17 reg [16:0] out_2; // ufix17 //HDL code generation from MATLAB function: TwoMultAdd_fixpt //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // % // Generated by MATLAB 9.2 and Fixed-Point Designer 5.4 % // % //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% assign TwoMultAdd_fixpt_mul_temp = a * b; assign TwoMultAdd_fixpt_2 = {1'b0, TwoMultAdd_fixpt_mul_temp}; assign TwoMultAdd_fixpt_mul_temp_1 = c * d; assign TwoMultAdd_fixpt_3 = {1'b0, TwoMultAdd_fixpt_mul_temp_1}; assign out_1 = TwoMultAdd_fixpt_2 + TwoMultAdd_fixpt_3; assign enb = clke_ena_i; always @(posedge clk or posedge reset) begin : out_reg_process if (reset == 1'b1) begin out_2 <= 17'b00000000000000000; end else begin if (enb) begin out_2 <= out_1; end end end assign clke_ena_o = clke_ena_i; assign out = out_2; endmodule // TwoMultAdd_fixpt

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

आइए नज़र डालते हैं कि क्वार्टस अब किस संश्लेषण करता है।

चित्र 5

और फिर, परिणाम अच्छे और अपेक्षित हैं।

नीचे दी गई तालिका उपयोग किए गए संसाधनों की तालिका दिखाती है - हम इसे ध्यान में रखते हैं।

चित्र 6

इस पहली खोज के लिए, मैथवर्क्स को एक क्रेडिट मिलता है। सब कुछ जटिल नहीं है, अनुमानित और वांछित परिणाम के साथ।

मैंने एक सरल उदाहरण में विस्तार से वर्णन किया है, एक डीएसपी ब्लॉक का आरेख प्रदान किया है, और एचडीएल-कोडर में रजिस्टर उपयोग सेटिंग्स का उपयोग करने की संभावनाओं का वर्णन किया है, जो "डिफ़ॉल्ट" सेटिंग्स से अलग हैं। यह एक कारण के लिए किया जाता है। इसके द्वारा मैं इस बात पर जोर देना चाहूंगा कि ऐसे सरल उदाहरण में भी, एचडीएल-कोडर का उपयोग करते समय, एफपीजीए आर्किटेक्चर और डिजिटल सर्किटरी की बुनियादी बातों का ज्ञान आवश्यक है, और सेटिंग्स को सचेत रूप से बदलना होगा।

इंटेल एचएलएस कंपाइलर

आइए C ++ में समान कार्यक्षमता के साथ कोड संकलित करने का प्रयास करें और देखें कि आखिरकार HLS संकलक का उपयोग करके FPGA में क्या संश्लेषित है।

तो C ++ कोड

 component unsigned int TwoMultAdd(unsigned char a, unsigned char b, unsigned char c, unsigned char d) { return (a*b)+(c*d); }

मैंने चर प्रकारों से बचने के लिए डेटा प्रकारों को चुना।

थोड़ी गहराई तय करने के लिए उन्नत तरीके हैं, लेकिन हमारा लक्ष्य एफपीजीए के तहत सी / सी ++ शैली में लिखे कार्यों को इकट्ठा करने की क्षमता का परीक्षण करना है, बिना किसी बदलाव के, सभी बॉक्स से बाहर।

चूंकि एचएलएस संकलक इंटेल का एक मूल उपकरण है, इसलिए हम एक विशेष संकलक के साथ कोड एकत्र करते हैं और क्वार्टस में तुरंत परिणाम की जांच करते हैं।

आइए उस सर्किट को देखें जो क्वार्टस संश्लेषण करता है।

चित्र 7

कंपाइलर ने इनपुट और आउटपुट में रजिस्टर बनाया, लेकिन सार आवरण मॉड्यूल में छिपा हुआ है। हम रैपर को तैनात करना शुरू करते हैं और ... अधिक से अधिक नेस्टेड मॉड्यूल देखें।

परियोजना की संरचना इस तरह दिखती है।

चित्र 8

इंटेल से एक स्पष्ट संकेत है "इस पर अपने हाथ मत जाओ!"। लेकिन हम कोशिश करेंगे, विशेष रूप से कार्यक्षमता जटिल नहीं है।

प्रोजेक्ट ट्री के आंत्र में | quartus_compile | TwoMultAdd: TwoMultAdd_inst | TwoMultAdd_internal: twomultadd_internal_inst | TwoMultAdd_fu.co |
nction_wrapper: TwoMultAdd_internal | TwoMultAdd_function: theTwoMultAdd_function | bb_TwoMultAdd_B1_start:
thebb_TwoMultAdd_B1_start | bb_TwoMultAdd_B1_start_stall_region: thebb_TwoMultAdd_B1_start_stall_region | i
_sfc_c1_wt_entry_twomultadd_c1_enter_twomultadd: thei_sfc_c1_wt_entry_twomultadd_c1_w_tomultad
d_aunroll_x | i_sfc_logic_c1_wt_entry_twomultadd_c1_enter_twomultadd13: thei_sfc_logic_c1_wt_entry_twom
ultadd_c1_enter_twomultadd13_aunroll_x | Mult1 वह मॉड्यूल है जिसकी आप तलाश कर रहे हैं।

हम क्वार्ट्स द्वारा संश्लेषित वांछित मॉड्यूल के आरेख को देख सकते हैं।

चित्र 9

इस योजना से क्या निष्कर्ष निकाला जा सकता है।

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

प्रयुक्त संसाधनों की तालिका से पता चलता है कि इससे क्या होता है।

चित्र 10

एचडीएल कोडर तालिका (चित्रा 6) के साथ परिणामों की तुलना करें।

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

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

आइए देखें कि अधिक जटिल परियोजनाओं के साथ हमारे विषय कैसे व्यवहार करते हैं।

दूसरी परीक्षा। "परिणाम के योग के साथ मैट्रिसेस का तत्व-वार गुणन"

यह फ़ंक्शन व्यापक रूप से छवि प्रसंस्करण में उपयोग किया जाता है: तथाकथित "मैट्रिक्स फ़िल्टर" । हम इसे उच्च-स्तरीय टूल का उपयोग करके बेचते हैं।

मैथवर्क द्वारा एचडीएल कोडर

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

MATLAB में फ़ंक्शन के लिए कोड निम्नानुसार है

 function [out] = mhls_conv2_manually(target,kernel) len = length(kernel); mult = target.*kernel; summ = sum(mult); out = summ/len; end

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

चित्र 11

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

हमने आवृत्ति को 100 मेगाहर्ट्ज पर सेट किया है, आइए देखें कि क्वार्टस प्रस्तावित सर्किट से क्या निचोड़ सकता है।

चित्र 12

यह देखा जा सकता है कि यह थोड़ा निकला: 33 मेगाहर्ट्ज तुच्छ दिखता है। गुणक और योजक की श्रृंखला में देरी लगभग 30 ns है। इस "अड़चन" से छुटकारा पाने के लिए, आपको कन्वेयर का उपयोग करने की आवश्यकता है: अंकगणित संचालन के बाद रजिस्टर डालें, जिससे महत्वपूर्ण पथ कम हो।

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

इसके अलावा, अनुकूलन के साथ स्थिति बदतर हो सकती है। उदाहरण के लिए, कुछ भी हमें कोड लिखने से रोकता है

 out = (sum(target.*kernel))/len;

यह MATLAB के लिए काफी पर्याप्त है, लेकिन एचडीएल के अनुकूलन की संभावना से हमें पूरी तरह से वंचित करता है।

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

नया कोड इस प्रकार है

 function [out] = mhls_conv2_manually(target,kernel) len = length(kernel); mult = target.*kernel; summ_1 = zeros([1,(len/2)]); summ_2 = zeros([1,(len/4)]); summ_3 = zeros([1,(len/8)]); for i=0:1:(len/2)-1 summ_1(i+1) = (mult(i*2+1)+mult(i*2+2)); end for i=0:1:(len/4)-1 summ_2(i+1) = (summ_1(i*2+1)+summ_1(i*2+2)); end for i=0:1:(len/8)-1 summ_3(i+1) = (summ_2(i*2+1)+summ_2(i*2+2)); end out = summ_3/len; end

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

चित्र 12

आदिम के सही लेआउट के साथ, आवृत्ति लगभग 3 गुना बढ़ जाती है, 88 मेगाहर्टज तक।

चित्र 13

अब अंतिम स्पर्श: अनुकूलन सेटिंग्स में, पाइपलाइन के तत्वों के रूप में sum_1, sum_2 और sum_3 निर्दिष्ट करें। हम Quartus में परिणामी कोड एकत्र करते हैं। योजना इस प्रकार है:

चित्र 14

अधिकतम आवृत्ति फिर से बढ़ जाती है और अब इसका मूल्य लगभग 195 मेगाहर्ट्ज है।

चित्र 15

चिप पर कितने संसाधन इस तरह के डिजाइन को ले जाएंगे? चित्र 16 वर्णित मामले के लिए प्रयुक्त संसाधनों की तालिका दिखाता है।

चित्र 16

इस उदाहरण पर विचार करने के बाद क्या निष्कर्ष निकाला जा सकता है?

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

मुख्य खतरा अतिरिक्त सेटिंग्स के बिना उत्पन्न कोड में रजिस्टरों की कमी है। इन रजिस्टरों के बिना, यहां तक कि वाक्यविन्यास त्रुटियों के बिना औपचारिक रूप से काम करने वाले एचडीएल कोड प्राप्त करने, आधुनिक वास्तविकताओं और विकास में ऐसे कोड का उपयोग अवांछनीय है।

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

यदि आप MATLAB डेवलपर हैं, तो रन बटन पर क्लिक करने और FPGA के तहत अपना कोड संकलित करने में जल्दबाजी न करें, याद रखें कि आपका कोड एक वास्तविक सर्किट में संश्लेषित किया जाएगा। =)

इंटेल एचएलएस कंपाइलर

उसी कार्यक्षमता के लिए, मैंने निम्नलिखित C / C ++ कोड लिखा

 component unsigned int conv(unsigned char *data, unsigned char *kernel) { unsigned int mult_res[16]; unsigned int summl; summl = 0; for (int i = 0; i < 16; i++) { mult_res[i] = data[i] * kernel[i]; summl = summl+mult_res[i]; } return summl/16; }

पहली चीज जो आपकी आंख को पकड़ती है वह उपयोग किए गए संसाधनों की मात्रा है।

चित्र 17

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

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

चित्र 18

आइए स्थिति को सुधारने का प्रयास करें। इसके लिए क्या आवश्यक है? यह सही है, अपनी आंखों को विरासत में बंद करें और कोड में क्रॉल करें, लेकिन अभी तक यह ज्यादा नहीं है।

FPGA के लिए कोड के अनुकूलन के लिए HLS के विशेष निर्देश हैं। हम अनियंत्रित निर्देश सम्मिलित करते हैं, जो समानांतर में हमारे लूप का विस्तार करना चाहिए:

 #pragma unroll for (int i = 0; i < 16; i++) { mult_res[i] = data[i] * kernel[i]; }

आइए देखें कि क्वार्टस ने इस पर क्या प्रतिक्रिया दी

चित्र 19

सबसे पहले, डीएसपी ब्लॉकों की संख्या पर ध्यान दें - उनमें से 16 हैं, जिसका अर्थ है कि समानांतर में गुणा किया जाता है।

हुर्रे! काम करता है! लेकिन यह पहले से ही कठिन है कि अन्य संसाधनों का उपयोग कितना बढ़ा है। सर्किट पूरी तरह से अपठनीय हो गया है।

चित्र 20

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

फिक्स्ड-पॉइंट का उपयोग करने के उद्देश्य से, टेम्पलेट कक्षाएं लागू की जाती हैं।

चित्र 21

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

आइए देखें कि यह व्यवहार में कैसा दिखता है।

हम निम्नानुसार कोड को संपादित करते हैं:

 component ac_fixed<16,16,false> conv(ac_fixed<8,8,false> *data, ac_fixed<8,8,false> *kernel) { ac_fixed<16,16,false>mult_res[16]; ac_fixed<32,32,false>summl; #pragma unroll for (int i = 0; i < 16; i++) { mult_res[i] = data[i] * kernel[i]; } for (int i = 0; i < 16; i++) { summl = summl+mult_res[i]; } return summl/16; }

और चित्र 20 से खौफनाक पास्ता के बजाय, हमें यह सुंदरता मिलती है:

चित्र 22

दुर्भाग्य से, उपयोग किए गए संसाधनों के साथ कुछ अजीब होता रहता है।

चित्र 23

लेकिन रिपोर्टों की एक विस्तृत समीक्षा से पता चलता है कि जो मॉड्यूल हमें सीधे दिलचस्पी देता है वह पर्याप्त से अधिक दिखता है:

चित्र 24

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

तीसरी परीक्षा। "RGB से HSV में संक्रमण"

इस लेख को लिखना शुरू करना, मुझे उम्मीद नहीं थी कि यह इतना बड़ा होगा। लेकिन मैं इस लेख के ढांचे में तीसरे और अंतिम को अस्वीकार नहीं कर सकता, एक उदाहरण।

सबसे पहले, यह मेरे अभ्यास से एक वास्तविक उदाहरण है, और इसकी वजह यह थी कि मैं उच्च-स्तरीय विकास साधनों की ओर देखने लगा।

दूसरे, पहले दो उदाहरणों से, हम यह अनुमान लगा सकते हैं कि डिजाइन जितना जटिल होगा, उच्च स्तर के उपकरण कार्य के साथ उतना ही खराब होंगे।

मैं प्रदर्शित करना चाहता हूं कि यह निर्णय त्रुटिपूर्ण है, और वास्तव में, यह कार्य जितना जटिल है, उच्च-स्तरीय विकास साधनों के फायदे उतने ही अधिक हैं।

पिछले साल, जब एक परियोजना पर काम कर रहा था, तो मुझे Aliexpress पर खरीदा गया कैमरा पसंद नहीं था, अर्थात्, रंग पर्याप्त रूप से संतृप्त नहीं थे। रंग संतृप्ति को अलग करने के लोकप्रिय तरीकों में से एक RGB रंग स्थान से HSV स्थान पर स्विच करना है, जहां मापदंडों में से एक संतृप्ति है। मुझे याद है कि मैंने संक्रमण फार्मूला कैसे खोला और एक गहरी साँस ली ... FPGA में ऐसी गणनाओं को लागू करना कुछ असाधारण नहीं है, लेकिन निश्चित रूप से कोड लिखने में समय लगेगा। इसलिए, RGB से HSV तक स्विच करने का सूत्र निम्नानुसार है:

चित्र 25

FPGA में इस तरह के एक एल्गोरिथ्म के कार्यान्वयन में दिन नहीं, बल्कि घंटे लगेंगे, और यह सब एचडीएल की बारीकियों के कारण बहुत सावधानी से किया जाना चाहिए, और सी ++ में या MATLAB में कार्यान्वयन करना होगा, मुझे लगता है, मिनट।

C ++ में, आप सीधे माथे में कोड लिख सकते हैं और फिर भी एक कार्यशील परिणाम प्राप्त कर सकते हैं।
मैंने C ++ में निम्नलिखित विकल्प लिखा

 struct color_space{ unsigned char rh; unsigned char gs; unsigned char bv; }; component color_space rgb2hsv(color_space rgb_0) { color_space hsv; float h,s,v,r,g,b; float max_col, min_col; r = static_cast<float>(rgb_0.rh)/255; g = static_cast<float>(rgb_0.gs)/255; b = static_cast<float>(rgb_0.bv)/255; max_col = std::max(std::max(r,g),b); min_col = std::min(std::min(r,g),b); // H if (max_col == min_col) h = 0; else if (max_col==r && g>=b) h = 60*((gb)/(max_col-min_col)); else if (max_col==r && g<b) h = 60*((gb)/(max_col-min_col))+360; else if (max_col==g) h = 60*((br)/(max_col-min_col))+120; else if (max_col==b) h = 60*((rg)/(max_col-min_col))+240; // S if (max_col == 0) s = 0; else { s = (1-(min_col/max_col))*100; } // V v = max_col*100; hsv.rh = static_cast<char>(h); hsv.gs = static_cast<char>(s); hsv.bv = static_cast<char>(v); return hsv; }

और क्वार्ट्स ने सफलतापूर्वक परिणाम को लागू किया, जैसा कि प्रयुक्त संसाधनों की तालिका से देखा जा सकता है।

चित्र 26

आवृत्ति बहुत अच्छी है।

चित्र 27

एचडीएल कोडर के साथ, चीजें थोड़ी अधिक जटिल हैं।

लेख को न बढ़ाने के लिए, मैं इस कार्य के लिए एक एम-स्क्रिप्ट प्रदान नहीं करूंगा, इससे कठिनाइयों का सामना नहीं करना चाहिए। माथे में लिखी गई एक एम-स्क्रिप्ट का उपयोग शायद ही कभी किया जा सकता है, लेकिन यदि आप कोड को संपादित करते हैं और सही ढंग से पाइपलाइनिंग के लिए स्थानों को निर्दिष्ट करते हैं, तो हमें एक कार्यशील परिणाम मिलता है। यह, ज़ाहिर है, कई दस मिनट लगेंगे, लेकिन घंटे नहीं।

C++ , .

, , , , — , FPGA , HDL.

निष्कर्ष

.

, , , .

, , . , , HDL, .

, FPGA FPGA . .

, — FPGA.

HLS compiler : , , , “best practices” .. MATLAB, , GUI , , , , , .

? — Intel HLS compiler. . HDL coder . , HDL coder , , . HLS, , , FPGA , .

Xilinx , — FPGA. , , Verilog/VHDL , . ( ), .

? , , , HDL .

, , , , .

हम एचडीएल के बिना एफपीजीए के तहत लिखते हैं। उच्च-स्तरीय विकास साधनों की तुलना

आपको FPGA के लिए उच्च-स्तरीय विकास उपकरण की आवश्यकता क्यों है?

उच्च-स्तरीय विकास उपकरण कहां से आते हैं?

उच्च-स्तरीय विकास साधनों की तुलना

एक का परीक्षण करें। "दो गुणक और एक योजक"

मैथवर्क्स द्वारा एचडीएल कोडर

इंटेल एचएलएस कंपाइलर

दूसरी परीक्षा। "परिणाम के योग के साथ मैट्रिसेस का तत्व-वार गुणन"

मैथवर्क द्वारा एचडीएल कोडर

इंटेल एचएलएस कंपाइलर

तीसरी परीक्षा। "RGB से HSV में संक्रमण"

निष्कर्ष

More articles: