सी ++ 17 में ओवरहेड के बिना रजिस्टरों के साथ टाइप-सुरक्षित कार्य: मूल्य-आधारित मेटाप्रोग्रामिंग

C ++, इसके सख्त टाइपिंग के कारण, कंपाइलर स्टेज पर प्रोग्रामर की मदद कर सकता है। हब पर पहले से ही बहुत सारे लेख हैं जो वर्णन करते हैं कि कैसे, इसको प्राप्त करने के लिए, प्रकारों का उपयोग करते हुए, और यह ठीक है। लेकिन मैंने जो पढ़ा है, उसमें एक दोष है। ++ दृष्टिकोण और CMSIS का उपयोग करते हुए C दृष्टिकोण की तुलना करें, जो कि माइक्रोकंट्रोलर प्रोग्रामिंग की दुनिया में परिचित है:

some_stream.set (Direction::to_periph) SOME_STREAM->CR |= DMA_SxCR_DIR_0 .inc_memory() | DMA_SxCR_MINC_Msk .size_memory (DataSize::word16) | DMA_SxCR_MSIZE_0 .size_periph (DataSize::word16) | DMA_SxCR_PSIZE_0 .enable_transfer_complete_interrupt(); | DMA_SxCR_TCIE_Msk; 

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

पहले मैं एक उदाहरण दूंगा कि मैं इसे कैसे देखना चाहता हूं। यह वांछनीय है कि यह पहले से परिचित C ++ दृष्टिकोण से बहुत भिन्न नहीं है।

 some_stream.set( dma_stream::direction::to_periph , dma_stream::inc_memory , dma_stream::memory_size::byte16 , dma_stream::periph_size::byte16 , dma_stream::transfer_complete_interrupt::enable ); 

सेट विधि में प्रत्येक पैरामीटर एक अलग प्रकार है जिसके द्वारा आप समझ सकते हैं कि आप किस रजिस्टर में मूल्य लिखना चाहते हैं, जिसका अर्थ है कि संकलन के दौरान आप रजिस्टरों तक पहुंच को अनुकूलित कर सकते हैं। विधि परिवर्तनशील है, इसलिए किसी भी तर्क हो सकते हैं, लेकिन एक जांच होनी चाहिए कि सभी तर्क इस परिधि के हैं।

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

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

 enum struct Enum1 { _0, _1, _2, _3 }; enum struct Enum2 { _0, _1, _2, _3 }; enum struct Enum3 { _0, _1, _2, _3, _4 }; enum struct Enum4 { _0, _1, _2, _3 }; 

पहले तीन एक परिधि से संबंधित होंगे, दूसरे से चौथे। इस प्रकार, यदि आप पहली परिधि की विधि में चौथे गणन का मान दर्ज करते हैं, तो एक संकलन त्रुटि होनी चाहिए, अधिमानतः समझने योग्य। इसके अलावा, पहले 2 लिस्टिंग एक रजिस्टर से संबंधित होंगे, दूसरे से दूसरे में।

चूँकि गणना के मान वास्तविक मूल्यों के अलावा अपने आप में कुछ भी संग्रहीत नहीं करते हैं, इसलिए एक अतिरिक्त प्रकार की आवश्यकता होती है, जो स्टोर करेगा, उदाहरण के लिए, यह गणना करने के लिए रजिस्टर के किस भाग में एक मुखौटा लिखा जाएगा।

 struct Enum1_traits { static constexpr std::size_t mask = 0b00111; }; struct Enum2_traits { static constexpr std::size_t mask = 0b11000; }; struct Enum3_traits { static constexpr std::size_t mask = 0b00111; }; struct Enum4_traits { static constexpr std::size_t mask = 0b00111; }; 

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

 template <class T> struct type_identity { using type = T; }; //    constexpr auto some_type = type_identity<Some_type>{}; //      using some_type_t = typename decltype(some_type)::type; #define TYPE(type_identity) typename decltype(type_identity)::type 

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

 constexpr auto traits(type_identity<Enum1>) { return type_identity<Enum1_traits>{}; } #define MAKE_TRAITS_WITH_MASK(enum, mask_) struct enum##_traits { \ static constexpr std::size_t mask = mask_; \ }; \ constexpr auto traits(type_identity<enum>) { \ return type_identity<enum##_traits>{}; \ } 

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

 struct Register1 : Enum1_traits, Enum2_traits { static constexpr std::size_t offset = 0x0; }; 

पता जहां रजिस्टर स्थित है, परिधि की शुरुआत से एक ऑफसेट के रूप में संग्रहीत किया जाता है।

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

 template <class...Ts> struct type_pack{}; using empty_pack = type_pack<>; 

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

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

 template<class Address> struct Periph1 { Periph1(Address) {} static constexpr auto registers = type_pack<Register1, Register2>{}; template<class...Ts> static constexpr void set(Ts...args) { ::set(registers, Address::value, args...); } }; 

सभी जो सेट विधि करता है वह एक निशुल्क फ़ंक्शन कहलाता है, इसमें सामान्यीकृत एल्गोरिथ्म के लिए आवश्यक सभी जानकारी गुजरती है।

मैं उन प्रकारों के उदाहरण दूंगा जो परिधि को एक पता प्रदान करते हैं।

 //    struct Address { static constexpr std::size_t value = SOME_PERIPH_BASE; }; //    ,    struct Address { static inline std::size_t value; template<class Pointer> Address(Pointer address) { value = reinterpret_cast<std::size_t>(address); } }; 

सामान्यीकृत एल्गोरिथ्म के लिए सभी जानकारी तैयार की जाती है, यह इसे लागू करने के लिए बनी हुई है। मैं इस फंक्शन का टेक्स्ट दूंगा।

 template<class...Registers, class...Args> constexpr void set(type_pack<Registers...> registers, std::size_t address, Args...args) { //       ,  value based  constexpr auto args_traits = make_type_pack(traits(type_identity<Args>{})...); //              static_assert(all_of(args_traits, [](auto arg){ return (std::is_base_of_v<TYPE(arg), Registers> || ...); }), "one of arguments in set method don`t belong to periph type"); //   ,      constexpr auto registers_for_write = filter(registers, [](auto reg){ return any_of(args_traits, [](auto arg){ //       o  reg? return std::is_base_of_v<TYPE(arg), TYPE(reg)>; }); }); //           foreach(registers_for_write, [=](auto reg){ auto value = register_value(reg, args...); auto offset = decltype(reg)::type::offset; write(address + offset, value); }); }; 

एक फ़ंक्शन को लागू करना जो तर्कों (विशिष्ट रजिस्टर फ़ील्ड) को type_pack में type_pack है, बहुत तुच्छ है। आपको याद दिला दूं कि टेम्प्लेट टाइप सूची की दीर्घवृत्त को अल्पविराम द्वारा अलग किए गए प्रकारों की सूची बताती है।

 template <class...Ts> constexpr auto make_type_pack(type_identity<Ts>...) { return type_pack<Ts...>{}; } 

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

 template <class F, class...Ts> constexpr auto all_of(type_pack<Ts...>, F f) { return (f(type_identity<Ts>{}) and ...); } 

यहां, पहली बार, 17 मानक की एक स्कैन अभिव्यक्ति लागू होती है। यह वह नवाचार है जिसने मेटाप्रोग्रामिंग के शौकीन लोगों के जीवन को सरल बनाया है। इस उदाहरण में, फ़ंक्शन च को सूची Ts में प्रत्येक प्रकार पर लागू किया जाता है, इसे type_identity परिवर्तित किया जाता है, और प्रत्येक कॉल का परिणाम I द्वारा एकत्र किया जाता है।

static_assert अंदर, यह एल्गोरिथ्म लागू किया जाता है। args_traits लिपटे type_identity को बारी-बारी से type_identity जाता है। लैम्ब्डा के अंदर, मानक मेटाफंक्शन std :: is_base_of का उपयोग किया जाता है, लेकिन चूंकि एक से अधिक रजिस्टर हो सकते हैं, OR लॉजिक के अनुसार रजिस्टरों में से प्रत्येक के लिए इसे निष्पादित करने के लिए एक स्कैन एक्सप्रेशन का उपयोग किया जाता है। नतीजतन, अगर कम से कम एक तर्क है, जिसके गुण कम से कम एक रजिस्टर के लिए बुनियादी नहीं हैं, तो static assert काम करेगा और एक स्पष्ट त्रुटि संदेश प्रदर्शित करेगा। यह समझना आसान है कि त्रुटि किस जगह से है (यह set विधि के लिए गलत तर्क पारित किया है) और इसे ठीक करें।

any_of एल्गोरिथ्म का कार्यान्वयन, जिसकी बाद में आवश्यकता होगी, बहुत समान है:

 template <class F, class...Ts> constexpr auto any_of(type_pack<Ts...>, F f) { return (f(type_identity<Ts>{}) or ...); } 

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

 template <class F, class...Ts> constexpr auto filter(type_pack<Ts...>, F f) { auto filter_one = [](auto v, auto f) { using T = typename decltype(v)::type; if constexpr (f(v)) return type_pack<T>{}; else return empty_pack{}; }; return (empty_pack{} + ... + filter_one(type_identity<Ts>{}, f)); } 

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

 template <class...Ts, class...Us> constexpr auto operator+ (type_pack<Ts...>, type_pack<Us...>) { return type_pack<Ts..., Us...>{}; } 

नए एल्गोरिथ्म को रजिस्टरों की सूची पर लागू करना, केवल उन लोगों को, जिन्हें हस्तांतरित तर्क लिखे जाने चाहिए, नई सूची में छोड़ दिए गए हैं।

अगले एल्गोरिथ्म की जरूरत होगी कि foreach । यह बस सूची में प्रत्येक प्रकार के लिए एक फ़ंक्शन लागू करता है, इसे type_identity में type_identity । यहां, स्कैन अभिव्यक्ति में एक अल्पविराम ऑपरेटर का उपयोग किया जाता है, जो अल्पविराम द्वारा वर्णित सभी क्रिया करता है और अंतिम क्रिया का परिणाम देता है।

 template <class F, class...Ts> constexpr void foreach(type_pack<Ts...>, F f) { (f(type_identity<Ts>{}), ...); } 

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

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

 template<class Register, class...Args> constexpr std::size_t register_value(type_identity<Register> reg, Args...args) { return (arg_value(reg, args) | ...); } 

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

 template<class Register, class Arg> constexpr std::size_t arg_value(type_identity<Register>, Arg arg) { constexpr auto arg_traits = traits(type_identity<Arg>{}); //   ,     if constexpr (not std::is_base_of_v<TYPE(arg_traits), Register>) return 0; constexpr auto mask = decltype(arg_traits)::type::mask; constexpr auto arg_shift = shift(mask); return static_cast<std::size_t>(arg) << arg_shift; } 

मास्क को स्वयं निर्धारित करने के लिए आप एल्गोरिथ्म लिख सकते हैं, लेकिन मैंने मौजूदा बिलिन फ़ंक्शन का उपयोग किया है।

 constexpr auto shift(std::size_t mask) { return __builtin_ffs(mask) - 1; } 

अंतिम फ़ंक्शन जो किसी विशिष्ट पते पर मान लिखता है, वह रहता है।

 inline void write(std::size_t address, std::size_t v) { *reinterpret_cast<std::size_t*>(address) |= v; } 

कार्य का परीक्षण करने के लिए, एक छोटा परीक्षण लिखा जाता है:

 // ,    volatile std::size_t arr[3]; int main() { //     ( ) //   ,         auto address = Address{arr}; auto mock_periph = Periph1{address}; //  1      //  3       3 //  4      //     0b00011001 (25) //    0b00000100 (4) mock_periph.set(Enum1::_1, Enum2::_3, Enum3::_4); // all ok // mock_periph.set(Enum4::_0); // must be compilation error } 

यहाँ लिखी गई हर चीज़ को एक साथ जोड़कर गॉडबोल्ट में संकलित किया गया । वहाँ कोई भी दृष्टिकोण के साथ प्रयोग कर सकता है। यह देखा जा सकता है कि लक्ष्य पूरा हो गया है: कोई अनावश्यक मेमोरी एक्सेस नहीं है। रजिस्टरों में लिखे जाने वाले मूल्य की गणना संकलन चरण में की जाती है:

 main: mov QWORD PTR Address::value[rip], OFFSET FLAT:arr or QWORD PTR arr[rip], 25 or QWORD PTR arr[rip+8], 4 mov eax, 0 ret 

पुनश्च:
टिप्पणियों के लिए सभी को धन्यवाद, उनके लिए धन्यवाद, मैंने दृष्टिकोण को थोड़ा संशोधित किया। आप यहां नया विकल्प देख सकते हैं ।

• हटाए गए सहायकों के प्रकार * _traits, मास्क को सीधे लिस्टिंग में बचाया जा सकता है।
  

   enum struct Enum1 { _0, _1, _2, _3, mask = 0b00111 }; 

• तर्कों के साथ रजिस्टर कनेक्शन अब विरासत के माध्यम से नहीं किया जाता है, अब यह एक स्थिर रजिस्टर फ़ील्ड है
  

   static constexpr auto params = type_pack<Enum1, Enum2>{}; 

• चूँकि कनेक्शन अब वंशानुक्रम के माध्यम से नहीं है, इसलिए मुझे लिखना होगा:
  

   template <class T, class...Ts> constexpr auto contains(type_pack<Ts...>, type_identity<T> v) { return ((type_identity<Ts>{} == v) or ...); } 

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

   template<auto...args> static void set() { constexpr auto values_for_write = extract(registers, args...); for (auto [value, offset] : values_for_write) { write(Address::value + offset, value); } } 

• एक्स्ट्रेक्ट फ़ंक्शन रजिस्टरों को लिखने के लिए मूल्यों की एक सरणी कॉन्स्टैक्स में आवंटित करता है। इसका कार्यान्वयन पिछले सेट फ़ंक्शन के समान है, सिवाय इसके कि यह रजिस्टर में सीधे नहीं लिखता है।
• मुझे एक अन्य मेटाफ़ंक्शन जोड़ना था जो टाइप_पैक को लैंबडा फ़ंक्शन के अनुसार एक सरणी में परिवर्तित करता है।
  

   template <class F, class...Ts> constexpr auto to_array(type_pack<Ts...> pack, F f) { return std::array{f(type_identity<Ts>{})...}; }