c++ - कहत - रेडियो एक्टिविटी की खोज किसने की




अत्यधिक रेडियोधर्मी वातावरण में उपयोग के लिए एक आवेदन संकलन (16)

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

क्या हम अपने कोड में बदलाव कर सकते हैं, या एकल घटना अपघटन के कारण होने वाली नरम त्रुटियों और स्मृति-भ्रष्टाचार की पहचान करने के लिए किए जाने वाले संकलन-समय में सुधार कर सकते हैं? क्या किसी अन्य डेवलपर्स को लंबे समय से चल रहे एप्लिकेशन पर नरम त्रुटियों के हानिकारक प्रभावों को कम करने में सफलता मिली?


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

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

सवाल यह है: जब आपकी मेमोरी अविश्वसनीय है तो मज़बूती से गणना कैसे करें?

नरम त्रुटियों की दर को कम करने के लिए (कम्प्यूटेशनल ओवरहेड की कीमत पर क्योंकि यह ज्यादातर सॉफ्टवेयर-आधारित समाधान होगा), आप निम्न कर सकते हैं:

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

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

यदि आप लचीला डेटा संरचनाओं में रुचि रखते हैं (जो कि हाल ही में, लेकिन एल्गोरिथम और अतिरेक इंजीनियरिंग में नया क्षेत्र है), तो मैं आपको निम्नलिखित दस्तावेजों को पढ़ने की सलाह देता हूं:

  • लचीला एल्गोरिदम डेटा संरचनाएं Giuseppe F.Italiano, यूनिवर्सिटा डी रोमा "टोर वेरटाटा" द्वारा इंट्रो

  • क्रिस्टियानो, पी।, डेमनी, ईडी, और किशोर, एस (2011)। Additive ओवरहेड के साथ दोषरहित दोष-सहिष्णु डेटा संरचनाएं। एल्गोरिदम और डेटा संरचनाओं में (पीपी 243-254)। स्प्रिंगर बर्लिन हीडलबर्ग।

  • फेरारो-पेट्रिलो, यू।, ग्रैंडोनी, एफ।, और इटैलिक, जीएफ (2013)। डेटा संरचनाएं मेमोरी दोषों के लिए लचीली होती हैं: शब्दकोशों का एक प्रायोगिक अध्ययन। जर्नल ऑफ़ एक्सपेरिमेंटल एल्गोरिथम (JEA), 18, 1-6।

  • Italiano, GF (2010)। लचीला एल्गोरिदम और डेटा संरचनाएं। एल्गोरिथम और जटिलता में (पीपी। 13-24)। स्प्रिंगर बर्लिन हीडलबर्ग।

यदि आप लचीले डेटा संरचनाओं के क्षेत्र के बारे में अधिक जानने में रुचि रखते हैं, तो आप Giuseppe F. Italiano के कार्यों की जांच कर सकते हैं (और रेफरी के माध्यम से अपना काम कर सकते हैं) और फ़ॉल्टी-रैम मॉडल (फिनोच्ची एट अल। 2005 में पेश किया गया)। और नोकिया 2008)।

/ संपादित करें: मैंने मुख्य रूप से RAM मेमोरी और डेटा स्टोरेज के लिए सॉफ्ट-एरर्स से बचाव / रिकवरी का वर्णन किया है, लेकिन मैंने कम्प्यूटेशन (CPU) त्रुटियों के बारे में बात नहीं की । अन्य उत्तर पहले से ही डेटाबेस में परमाणु लेनदेन का उपयोग करने पर इंगित करते हैं, इसलिए मैं एक और सरल योजना का प्रस्ताव दूंगा: अतिरेक और बहुसंख्यक वोट

विचार यह है कि आप बस प्रत्येक गणना के लिए x एक ही संगणना करते हैं, और परिणाम को x भिन्न चर (x> = 3 के साथ) में संग्रहीत करते हैं। फिर आप अपने एक्स चर की तुलना कर सकते हैं :

  • यदि वे सभी सहमत हैं, तो कोई भी गणना त्रुटि नहीं है।
  • यदि वे असहमत हैं, तो आप सही मूल्य प्राप्त करने के लिए एक बहुसंख्यक वोट का उपयोग कर सकते हैं, और इसका मतलब यह है कि गणना आंशिक रूप से दूषित हो गई थी, आप यह जांचने के लिए एक सिस्टम / प्रोग्राम स्टेट स्कैन को ट्रिगर कर सकते हैं कि बाकी ठीक है।
  • यदि बहुमत का वोट एक विजेता निर्धारित नहीं कर सकता है (सभी x मान अलग-अलग हैं), तो यह आपके लिए एक सही संकेत है कि आप असफल प्रक्रिया को ट्रिगर करें (रिबूट, उपयोगकर्ता के लिए एक अलर्ट बढ़ाएं, आदि)।

यह अतिरेक योजना ECC (व्यावहारिक रूप से O (1)) की तुलना में बहुत तेज़ है और यह आपको एक स्पष्ट संकेत प्रदान करती है जब आपको असफल होने की आवश्यकता होती है । बहुसंख्यक वोट भी (लगभग) दूषित उत्पादन न करने और मामूली संगणना त्रुटियों से उबरने की गारंटी है , क्योंकि x संगणना को समान उत्पादन देने की संभावना असीम है (क्योंकि संभावित आउटपुट की एक बड़ी मात्रा है, यह लगभग असंभव है। बेतरतीब ढंग से 3 बार एक ही मिलता है, और भी कम संभावना है अगर x> 3)।

इसलिए बहुमत वाले वोट से आप दूषित आउटपुट से सुरक्षित हैं, और अतिरेक x == 3 के साथ, आप 1 त्रुटि को पुनर्प्राप्त कर सकते हैं (x == 4 के साथ यह 2 त्रुटियों को पुनर्प्राप्त करने योग्य होगा, आदि - सटीक समीकरण वह है nb_error_recoverable == (x-2) जहां x संख्या है गणना की पुनरावृत्ति क्योंकि आपको बहुमत मत का उपयोग करके पुनर्प्राप्त करने के लिए कम से कम 2 सहमत गणनाओं की आवश्यकता होती है)।

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

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


आप जो पूछते हैं वह काफी जटिल विषय है - आसानी से जवाबदेह नहीं है। अन्य उत्तर ठीक हैं, लेकिन उन्होंने उन सभी चीजों का एक छोटा सा हिस्सा कवर किया है जो आपको करने की ज़रूरत है।

जैसा कि टिप्पणियों में देखा गया है , हार्डवेयर समस्याओं को 100% ठीक करना संभव नहीं है, हालांकि उच्च प्रोबिली के साथ संभव है कि वे अपनी तकनीकों का उपयोग करके उन्हें कम या पकड़ सकें।

यदि मैं आप होता, तो मैं उच्चतम सुरक्षा अखंडता स्तर स्तर (एसआईएल -4) का सॉफ्टवेयर बनाता । IEC 61513 दस्तावेज़ (परमाणु उद्योग के लिए) प्राप्त करें और इसका पालन करें।


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

वॉचडॉग अवधारणा के समान ही समय सीमा है। किसी फ़ंक्शन को कॉल करने से पहले एक हार्डवेयर टाइमर प्रारंभ करें। यदि फ़ंक्शन समय सीमा टाइमर से पहले वापस नहीं आता है, तो स्टैक को फिर से लोड करें और फिर से प्रयास करें। यदि यह 3/5 के बाद भी विफल रहता है, तो आपको ROM से पुनः लोड करने की आवश्यकता है।

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

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


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

उत्तर आमतौर पर स्वचालित इकाई परीक्षण है। परीक्षण हार्नेस लिखें जो विकास प्रणाली पर कोड का उपयोग करते हैं, फिर लक्ष्य प्रणाली पर समान परीक्षण हार्नेस चलाते हैं। मतभेदों के लिए देखो!

अपने एम्बेडेड डिवाइस पर इरेटा के लिए भी जाँच करें। आपको लग सकता है कि "ऐसा न करें क्योंकि यह दुर्घटनाग्रस्त हो जाएगा, इसलिए कंपाइलर विकल्प और कंपाइलर इसके आसपास काम करेंगे"।

संक्षेप में, आपके कोड में क्रैश का सबसे संभावित स्रोत बग है। जब तक आप यह सुनिश्चित नहीं कर लेते हैं कि यह मामला नहीं है, तब तक चिंता न करें (अभी तक) अधिक गूढ़ विफलता मोड के बारे में।


कैसे अपने आवेदन के कई उदाहरणों को चलाने के बारे में। यदि क्रैश यादृच्छिक मेमोरी बिट परिवर्तनों के कारण होते हैं, तो संभावना है कि आपके कुछ ऐप इंस्टेंसेस इसे सटीक परिणाम देंगे। यह संभवतः काफी आसान है (सांख्यिकीय पृष्ठभूमि वाले किसी व्यक्ति के लिए) यह गणना करने के लिए कि आपको अपनी इच्छा के अनुसार छोटे समग्र त्रुटि प्राप्त करने के लिए कितने फ्लॉप संभावना की आवश्यकता है।


चूंकि आप विशेष रूप से सॉफ़्टवेयर समाधान के लिए पूछते हैं, और आप सी ++ का उपयोग कर रहे हैं, तो अपने खुद के, सुरक्षित डेटाैटेस बनाने के लिए ऑपरेटर ओवरलोडिंग का उपयोग क्यों नहीं करें? उदाहरण के लिए:

उपयोग करने के बजाय uint32_t (और double , int64_t आदि), अपना खुद का बनाएं SAFE_uint32_t जिसमें uint32_t का एक बहु (न्यूनतम 3) होता है। उन सभी ऑपरेशनों को ओवरलोड करें जो आप चाहते हैं (* + - / << >> = ==! = आदि), प्रदर्शन करने के लिए, और प्रत्येक आंतरिक मूल्य पर ओवरलोड किए गए संचालन को स्वतंत्र रूप से करें, अर्थात एक बार ऐसा न करें और परिणाम की प्रतिलिपि बनाएँ। पहले और बाद में, दोनों देखें कि सभी आंतरिक मान मेल खाते हैं। यदि मान मेल नहीं खाते हैं, तो आप गलत को सबसे आम के साथ मान में अपडेट कर सकते हैं। यदि कोई सबसे आम मूल्य नहीं है, तो आप सुरक्षित रूप से सूचित कर सकते हैं कि कोई त्रुटि है।

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

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


यदि आपका हार्डवेयर विफल हो जाता है तो आप इसे पुनर्प्राप्त करने के लिए मैकेनिकल स्टोरेज का उपयोग कर सकते हैं। यदि आपका कोड आधार छोटा है और कुछ भौतिक स्थान हैं तो आप एक यांत्रिक डेटा स्टोर का उपयोग कर सकते हैं।

सामग्री की एक सतह होगी जो विकिरण से प्रभावित नहीं होगी। मल्टीपल गियर होंगे। एक यांत्रिक पाठक सभी गियर पर चलेगा और ऊपर और नीचे जाने के लिए लचीला होगा। डाउन का मतलब है कि यह 0 है और इसका मतलब है कि यह 1. है। 0 और 1 से आप अपना कोड आधार बना सकते हैं।


यहां बड़ी मात्रा में उत्तर दिए गए हैं, लेकिन मैं इस बारे में अपने विचारों को समेटने की कोशिश करूंगा।

कुछ क्रैश या सही तरीके से काम नहीं करना आपकी अपनी गलतियों का परिणाम हो सकता है - तब समस्या का पता लगाने पर इसे आसानी से ठीक करना चाहिए। लेकिन हार्डवेयर के विफल होने की भी संभावना है - और यह मुश्किल है अगर समग्र रूप से ठीक करना असंभव नहीं है।

मैं पहले समस्याग्रस्त स्थिति को लॉग (स्टैक, रजिस्टर, फंक्शन कॉल) द्वारा पकड़ने की कोशिश करने की सलाह दूंगा - या तो उन्हें फ़ाइल में कहीं लॉग इन करके, या उन्हें किसी तरह सीधे ट्रांसमिट करके ("अरे नहीं - मैं क्रैश हो रहा हूं")।

ऐसी त्रुटि स्थिति से पुनर्प्राप्ति या तो रिबूट है (यदि सॉफ़्टवेयर अभी भी जीवित है और किकिंग कर रहा है) या हार्डवेयर रीसेट (जैसे hw watchdogs)। पहले से शुरू करना आसान।

यदि समस्या हार्डवेयर से संबंधित है - तो लॉगिंग से आपको यह पहचानने में मदद मिलेगी कि कौन सी फ़ंक्शन कॉल समस्या होती है और यह आपको जानकारी दे सकती है कि क्या काम नहीं कर रहा है और कहां है।

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

यदि समस्या कुछ समय बाद होती है - तो स्टैक ओवरफ्लो पर संदेह किया जा सकता है - फिर स्टैक पॉइंट रजिस्टरों की निगरानी करना बेहतर होता है - अगर वे लगातार बढ़ते हैं।

और यदि आप "हैलो वर्ल्ड" एप्लिकेशन के प्रकार तक अपने कोड को पूरी तरह से कम करने का प्रबंधन करते हैं - और यह अभी भी बेतरतीब ढंग से विफल हो रहा है - तो हार्डवेयर समस्याओं की उम्मीद की जाती है - और "हार्डवेयर अपग्रेड" होने की आवश्यकता है - मतलब ऐसे सीपीयू / रैम का आविष्कार करें / ... -हार्डवेयर संयोजन जो विकिरण को बेहतर ढंग से सहन करेगा।

सबसे महत्वपूर्ण बात यह है कि अगर मशीन पूरी तरह से बंद / रीसेट हो जाती है या काम नहीं करती है तो आप अपने लॉग को कैसे प्राप्त कर सकते हैं - शायद पहली बात बूटस्टैप को करना चाहिए - समस्याग्रस्त स्थिति में प्रवेश करने पर एक हेड बैक होम है।

यदि आपके वातावरण में सिग्नल को प्रसारित करना और प्रतिक्रिया प्राप्त करना संभव है - तो आप किसी प्रकार के ऑनलाइन दूरस्थ डीबगिंग वातावरण का निर्माण करने का प्रयास कर सकते हैं, लेकिन तब आपके पास कम से कम संचार माध्यम काम करने वाले और कुछ प्रोसेसर / कार्यशील अवस्था में कुछ रैम होने चाहिए। और दूरस्थ डिबगिंग से मेरा मतलब है कि GDB / gdb स्टब तरह का दृष्टिकोण या आपको अपने आवेदन से वापस प्राप्त करने की आवश्यकता के अपने स्वयं के कार्यान्वयन (उदाहरण के लिए, लॉग फ़ाइलें डाउनलोड करें, कॉल स्टैक डाउनलोड करें, राम डाउनलोड करें, पुनः आरंभ करें)


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

दूसरा, जहां संभव हो, भ्रष्टाचार को सही करना और जारी रखना । इसका मतलब अक्सर चेक टेबल और निरंतर टेबल (और प्रोग्राम कोड यदि आप कर सकते हैं) को ठीक करना है; शायद प्रत्येक बड़े ऑपरेशन से पहले या एक समयबद्ध व्यवधान पर, और संरचनाओं में वैरिएबल को संग्रहीत करना जो स्वतः पूर्ण (फिर से प्रत्येक प्रमुख ऑप से पहले या समयबद्ध व्यवधान पर 3 से बहुमत का वोट लेते हैं और एक एकल विचलन है तो सही)। यदि संभव हो तो सुधारों को लॉग करें।

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


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


ऐसे परिवेशों में दृढ़ता से व्यवहार करने वाले कार्यक्रमों को लिखने के लिए सी का उपयोग करना संभव हो सकता है, लेकिन केवल अगर कंपाइलर अनुकूलन के अधिकांश रूप अक्षम हैं। ऑप्टिमाइज़ करने वाले कंपाइलरों को "अधिक कुशल" वाले कई प्रतीत होने वाले-निरर्थक कोडिंग पैटर्न को बदलने के लिए डिज़ाइन किया गया है, और कोई सुराग नहीं हो सकता है कि प्रोग्रामर x==42 का कारण परीक्षण कर रहा है जब कंपाइलर जानता है कि कोई रास्ता नहीं है x संभवतः किसी और चीज को पकड़ सकता है क्योंकि प्रोग्रामर कुछ अन्य मान रखने वाले x के साथ कुछ कोड के निष्पादन को रोकना चाहता है - यहां तक ​​कि उन मामलों में जहां एकमात्र तरीका यह मान सकता है कि अगर सिस्टम को किसी प्रकार का विद्युत गड़बड़ प्राप्त हुआ हो।

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

... code that checks system state
if (system_state_favors_activation)
{
  prepare_for_activation();
  ... code that checks system state again
  if (system_state_is_valid)
  {
    if (system_state_favors_activation)
      trigger_activation();
  }
  else
    perform_safety_shutdown_and_restart();
}
cancel_preparations();

यदि कोई कंपाइलर अपेक्षाकृत शाब्दिक रूप से कोड का अनुवाद करता है, और अगर prepare_for_activation() लिए सभी जाँच की prepare_for_activation() बाद दोहराया जाता prepare_for_activation() , सिस्टम लगभग किसी भी प्रशंसनीय एकल गड़बड़ घटना के खिलाफ मजबूत हो सकता है, यहां तक ​​कि जो प्रोग्राम काउंटर को मनमाने ढंग से भ्रष्ट करेगा ढेर। अगर किसी कॉल के prepare_for_activation() होने के कुछ समय बाद ही कोई गड़बड़ दिखाई देती है, तो इसका मतलब यह है कि सक्रियता उपयुक्त होगी (क्योंकि कोई अन्य कारण नहीं prepare_for_activation() को prepare_for_activation() से पहले बुलाया जाएगा)। यदि prepare_for_activation() कारण कोड prepare_for_activation() अनुचित रूप से पहुंचने का कारण बनता है, लेकिन बाद में कोई गड़बड़ घटना नहीं होती है, तो कोड के लिए बाद में trigger_activation() तक पहुंचने का कोई रास्ता नहीं होगा, बिना सत्यापन जाँच या कॉलिंग_पंक्चर के पहले पास होने पर। निष्पादन उस समय के बाद trigger_activation() के संदर्भ में हो सकता है, जिसे prepare_for_activation() रिटर्न कहा जाता है, लेकिन कॉल करने के लिए cancel_preparations() करने के लिए कॉल करने के लिए prepare_for_activation() कर दिया गया है।

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


क्या आप एक watchdog है मदद कर सकता है। 1980 के दशक में औद्योगिक कंप्यूटिंग में वॉचडॉग का बड़े पैमाने पर उपयोग किया गया था। हार्डवेयर विफलताएं तब बहुत अधिक सामान्य थीं - एक अन्य उत्तर भी उस अवधि को संदर्भित करता है।

एक वॉचडॉग एक संयुक्त हार्डवेयर / सॉफ्टवेयर सुविधा है। हार्डवेयर एक साधारण काउंटर है जो एक संख्या (1023) को शून्य से नीचे गिना जाता है। TTL या अन्य तर्क का उपयोग किया जा सकता है।

सॉफ्टवेयर को इस तरह से डिजाइन किया गया है कि एक रूटीन सभी आवश्यक प्रणालियों के सही संचालन की निगरानी करता है। यदि यह रूटीन सही तरीके से पूरा होता है = कंप्यूटर ठीक चलता है, तो यह काउंटर को 1023 पर सेट करता है।

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

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

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


यह एक अत्यंत व्यापक विषय है। असल में, आप वास्तव में स्मृति भ्रष्टाचार से उबर नहीं सकते हैं, लेकिन आप कम से कम तुरंत असफल होने का प्रयास कर सकते हैं । यहां कुछ तकनीकों का उपयोग किया जा सकता है:

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

  • अतिरेक के साथ वैरिएबल स्टोर करें । यदि आपके पास एक महत्वपूर्ण चर x , तो इसका मान x1 , x2 और x3 में लिखें और इसे (x1 == x2) ? x2 : x3 रूप में पढ़ें (x1 == x2) ? x2 : x3 (x1 == x2) ? x2 : x3

  • कार्यक्रम प्रवाह निगरानी लागू करें। मुख्य पाश से बुलाए गए महत्वपूर्ण कार्यों / शाखाओं में एक अद्वितीय मूल्य के साथ एक वैश्विक ध्वज XOR। लगभग 100% परीक्षण कवरेज के साथ विकिरण रहित वातावरण में कार्यक्रम चलाना आपको चक्र के अंत में ध्वज के स्वीकार्य मूल्यों की सूची प्रदान करना चाहिए। यदि आप विचलन देखते हैं तो रीसेट करें।

  • स्टैक पॉइंटर की निगरानी करें । मुख्य लूप की शुरुआत में, स्टैक पॉइंटर की उसके अपेक्षित मूल्य के साथ तुलना करें। विचलन पर रीसेट करें।


यहाँ कुछ विचार और विचार दिए गए हैं:

ROM का अधिक रचनात्मक रूप से उपयोग करें।

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

स्टैक के लिए अपनी सर्वश्रेष्ठ रैम का उपयोग करें।

स्टैक में एसईयू संभवतः दुर्घटनाओं का सबसे संभावित स्रोत हैं, क्योंकि यह वह जगह है जहां सूचकांक चर, स्थिति चर, वापसी पते और विभिन्न प्रकार के संकेत आमतौर पर रहते हैं।

टाइमर-टिक और वॉचडॉग टाइमर दिनचर्या को लागू करें।

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

सॉफ़्टवेयर में error-correcting-codes लागू करें।

आप त्रुटियों का पता लगाने और / या त्रुटियों को ठीक करने में सक्षम होने के लिए अपने डेटा में अतिरेक जोड़ सकते हैं। यह प्रसंस्करण समय जोड़ देगा, संभवतः लंबे समय तक विकिरण के संपर्क में आने वाले प्रोसेसर को छोड़ देगा, इस प्रकार त्रुटियों की संभावना बढ़ जाएगी, इसलिए आपको व्यापार-बंद पर विचार करना चाहिए।

कैश को याद रखें।

अपने सीपीयू कैश के आकार की जाँच करें। हाल ही में आपके द्वारा एक्सेस या संशोधित किया गया डेटा संभवतः कैश के भीतर होगा। मेरा मानना ​​है कि आप कम से कम कुछ कैश (एक बड़े प्रदर्शन लागत पर) को अक्षम कर सकते हैं; आपको यह देखने की कोशिश करनी चाहिए कि कैसे SEUs के लिए अतिसंवेदनशील हैं। यदि कैश रैम की तुलना में कठिन हैं, तो आप नियमित रूप से महत्वपूर्ण डेटा पढ़ और फिर से लिख सकते हैं ताकि यह सुनिश्चित हो सके कि यह कैश में रहता है और रैम को लाइन में वापस लाता है।

पृष्ठ-दोष संचालकों का चतुराई से उपयोग करें।

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

महत्वपूर्ण चीजों (जो सब कुछ हो सकता है) के लिए विधानसभा भाषा का उपयोग करें।

असेंबली लैंग्वेज के साथ, आप जानते हैं कि रजिस्टर में क्या है और रैम में क्या है; आप जानते हैं कि CPU किस विशेष रैम तालिकाओं का उपयोग कर रहा है, और आप अपने जोखिम को कम रखने के लिए गोल चक्कर में चीजों को डिज़ाइन कर सकते हैं।

वास्तव में उत्पन्न असेंबली भाषा को देखने के लिए objdump का उपयोग करें, और यह objdump करें कि आपकी प्रत्येक दिनचर्या में कितना कोड है।

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

याद रखें कि यह संभावनाओं का खेल है।

एक टिप्पणीकार ने कहा

त्रुटियों को पकड़ने के लिए आपके द्वारा लिखी जाने वाली प्रत्येक दिनचर्या स्वयं को उसी कारण से विफल करने के अधीन होगी।

हालांकि यह सच है, सही ढंग से काम करने के लिए एक चेक रूटीन के लिए कोड (कोड) और डेटा के 100 बाइट्स में त्रुटियों की संभावना कहीं और त्रुटियों की संभावना से बहुत छोटी है। यदि आपकी ROM बहुत विश्वसनीय है और लगभग सभी कोड / डेटा वास्तव में ROM में हैं तो आपके अंतर और भी बेहतर हैं।

निरर्थक हार्डवेयर का उपयोग करें।

समान कोड वाले 2 या अधिक समान हार्डवेयर सेटअप का उपयोग करें। यदि परिणाम भिन्न होते हैं, तो एक रीसेट चालू होना चाहिए। 3 या अधिक उपकरणों के साथ आप "वोटिंग" प्रणाली का उपयोग करके यह पहचानने का प्रयास कर सकते हैं कि किसके साथ समझौता किया गया है।


सॉफ्टवेयर / फर्मवेयर विकास और लघु उपग्रहों के पर्यावरण परीक्षण * के साथ लगभग 4-5 वर्षों के लिए काम करना, मैं यहां अपना अनुभव साझा करना चाहूंगा।

* ( छोटे उपग्रहों को अपने इलेक्ट्रॉनिक घटकों के लिए अपेक्षाकृत छोटे, सीमित आकारों के कारण बड़े उपग्रहों की तुलना में एकल इवेंट अपसेट होने का खतरा अधिक होता है )

बहुत संक्षिप्त और प्रत्यक्ष होने के लिए: सॉफ़्टवेयर / फ़र्मवेयर द्वारा स्वयं के बिना पता लगाने योग्य, गलत स्थिति से उबरने के लिए कोई तंत्र नहीं है, कम से कम, सॉफ़्टवेयर / फ़र्मवेयर के न्यूनतम कार्यशील संस्करण की एक प्रति कहीं न कहीं वसूली के उद्देश्य से - और हार्डवेयर का समर्थन करने के साथ वसूली (कार्यात्मक)।

अब, इस स्थिति को सामान्य रूप से हार्डवेयर और सॉफ्टवेयर स्तर दोनों में नियंत्रित किया जाता है। यहाँ, आप अनुरोध के रूप में, मैं सॉफ्टवेयर स्तर में हम क्या कर सकते हैं साझा करेंगे।

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

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

    1. बाहरी सिस्टम से कमांड सुनने में सक्षम,
    2. वर्तमान सॉफ्टवेयर / फर्मवेयर को अपडेट करने में सक्षम,
    3. बुनियादी ऑपरेशन के हाउसकीपिंग डेटा की निगरानी करने में सक्षम।
  3. ... कॉपी ... कहीं ... अनावश्यक सॉफ्टवेयर / फर्मवेयर कहीं है।

    1. आप निरर्थक हार्डवेयर के साथ या उसके बिना, अपने ARM uC में निरर्थक सॉफ्टवेयर / फर्मवेयर रखने की कोशिश कर सकते हैं। यह आम तौर पर दो या अधिक समान सॉफ्टवेयर / फर्मवेयर अलग-अलग पते पर होता है जो एक-दूसरे को दिल की धड़कन भेजते हैं - लेकिन एक समय में केवल एक ही सक्रिय होगा। यदि एक या अधिक सॉफ़्टवेयर / फ़र्मवेयर अप्रतिसादी होने पर जाना जाता है, तो अन्य सॉफ़्टवेयर / फ़र्मवेयर पर जाएँ। इस दृष्टिकोण का उपयोग करने का लाभ यह है कि हम त्रुटि होने के तुरंत बाद कार्यात्मक प्रतिस्थापन कर सकते हैं - बिना किसी बाहरी सिस्टम / पार्टी से संपर्क किए जो त्रुटि का पता लगाने और (उपग्रह मामले में) मरम्मत के लिए जिम्मेदार है, यह आमतौर पर मिशन नियंत्रण केंद्र है ( एमसीसी))।

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

    2. लेकिन अगर आप ऐसा नहीं कर रहे हैं, तो आपके पास अपने बाहरी सिस्टम में कम से कम एक कॉपी होनी चाहिए जो डिवाइस के संपर्क में आ सकती है और सॉफ़्टवेयर / फ़र्मवेयर को अपडेट कर सकती है (सैटेलाइट केस में, यह फिर से मिशन कंट्रोल सेंटर है)।

    3. आपके पास आपके डिवाइस में आपके स्थायी मेमोरी स्टोरेज में कॉपी भी हो सकती है जिसे रनिंग सिस्टम के सॉफ्टवेयर / फर्मवेयर को पुनर्स्थापित करने के लिए ट्रिगर किया जा सकता है
  4. ... पता लगाने योग्य त्रुटिपूर्ण स्थिति .. त्रुटि का पता लगाने योग्य होना चाहिए, आमतौर पर हार्डवेयर त्रुटि सुधार / डिटेक्शन सर्किट या त्रुटि सुधार / पता लगाने के लिए एक छोटे से कोड द्वारा। इस तरह के कोड को छोटे, कई और मुख्य सॉफ्टवेयर / फर्मवेयर से स्वतंत्र रखना सबसे अच्छा है। इसका मुख्य कार्य केवल जाँच / सुधार के लिए है। यदि हार्डवेयर सर्किट / फर्मवेयर विश्वसनीय है (जैसे कि यह अधिक विकिरण है, जो कि चूहों की तुलना में कठोर है - या कई सर्किट / लॉजिक्स हैं), तो आप इसके साथ त्रुटि-सुधार करने पर विचार कर सकते हैं। लेकिन अगर यह नहीं है, तो इसे त्रुटि-पहचान के रूप में बनाना बेहतर है। सुधार बाहरी प्रणाली / उपकरण द्वारा किया जा सकता है। त्रुटि सुधार के लिए, आप हेमिंग / गोलय 23 जैसे बुनियादी त्रुटि सुधार एल्गोरिथ्म का उपयोग करने पर विचार कर सकते हैं, क्योंकि उन्हें सर्किट / सॉफ्टवेयर दोनों में अधिक आसानी से लागू किया जा सकता है। लेकिन यह अंततः आपकी टीम की क्षमता पर निर्भर करता है। त्रुटि का पता लगाने के लिए, आमतौर पर सीआरसी का उपयोग किया जाता है।

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

एक घटना से परेशान फर्मवेयर की त्रुटि के लिए ऊपर दिए गए सुझाव के अलावा, एक घटना से परेशान होना चाहूंगा, मैं आपको सुझाव देना चाहूंगा:

  1. अंतर-सबसिस्टम संचार प्रोटोकॉल में त्रुटि का पता लगाने और / या त्रुटि सुधार एल्गोरिथ्म। अन्य प्रणाली से प्राप्त अपूर्ण / गलत संकेतों से बचने के लिए यह लगभग एक और होना चाहिए

  2. अपने एडीसी रीडिंग में फ़िल्टर करें। सीधे एडीसी पढ़ने का उपयोग करें। इसे माध्यिका फ़िल्टर, माध्य फ़िल्टर या किसी अन्य फ़िल्टर द्वारा फ़िल्टर करें - कभी भी एकल रीडिंग मान पर भरोसा न करें नमूना अधिक, कम नहीं - यथोचित।


यह उत्तर मानता है कि आप एक ऐसी प्रणाली के साथ संबंध रखते हैं जो एक ऐसी प्रणाली है जो न्यूनतम लागत या तेज है; रेडियोधर्मी चीजों के साथ खेलने वाले अधिकांश लोग गति / लागत पर शुद्धता / सुरक्षा को महत्व देते हैं

कई लोगों ने सुझाव दिया है कि हार्डवेयर परिवर्तन आप कर सकते हैं (ठीक है - पहले से ही उत्तर में बहुत सारी अच्छी चीजें हैं और मुझे यह सब दोहराने का इरादा नहीं है), और दूसरों ने अतिरेक का सुझाव दिया है (महान सिद्धांत में), लेकिन मुझे नहीं लगता है किसी ने सुझाव दिया है कि कैसे अतिरेक व्यवहार में काम कर सकता है। आप कैसे असफल हो जाते हैं? आपको कैसे पता चलेगा कि कुछ गलत हुआ है? कई प्रौद्योगिकियां इस आधार पर काम करती हैं कि सब कुछ काम करेगा, और विफलता इस प्रकार से निपटने के लिए एक मुश्किल चीज है। हालाँकि, पैमाने के लिए डिज़ाइन की गई कुछ वितरित कंप्यूटिंग प्रौद्योगिकियाँ असफलता की उम्मीद करती हैं (आखिरकार पर्याप्त पैमाने के साथ, एक नोड की विफलता एक MTBF के साथ किसी एक नोड के लिए अपरिहार्य है); आप अपने पर्यावरण के लिए इसका उपयोग कर सकते हैं।

यहाँ कुछ विचार हैं:

  • सुनिश्चित करें कि आपका पूरा हार्डवेयर n बार दोहराया गया है (जहाँ n 2 से अधिक है, और अधिमानतः विषम है), और यह कि प्रत्येक हार्डवेयर तत्व एक दूसरे हार्डवेयर तत्व के साथ संचार कर सकता है। ईथरनेट ऐसा करने का एक स्पष्ट तरीका है, लेकिन कई अन्य सरल मार्ग हैं जो बेहतर सुरक्षा देंगे (उदाहरण के लिए CAN)। सामान्य घटकों (यहां तक ​​कि बिजली की आपूर्ति) को कम से कम करें। इसका मतलब हो सकता है कि उदाहरण के लिए कई स्थानों पर एडीसी इनपुट का नमूना लिया जाए।

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

  • राज्य के परिवर्तनों के लिए एक कोरम प्रोटोकॉल को अपनाएं। उदाहरण के लिए RAFT देखें। जैसा कि आप C ++ में काम कर रहे हैं, इसके लिए अच्छी तरह से ज्ञात लाइब्रेरी हैं। FSM में परिवर्तन केवल तभी किया जाएगा जब अधिकांश नोड्स सहमत हों। प्रोटोकॉल स्टैक और कोरम प्रोटोकॉल के लिए अपने आप को रोल करने के बजाय एक ज्ञात अच्छे पुस्तकालय का उपयोग करें, या अतिरेक पर आपके सभी अच्छे काम तब बर्बाद हो जाएंगे जब कोरम प्रोटोकॉल लटका हुआ है।

  • सुनिश्चित करें कि आप अपने FSM को चेकसम (जैसे CRC / SHA), और FSM में ही CRC / SHA को स्टोर करें (साथ ही मैसेज को ट्रांसमिट करने के साथ-साथ मैसेजेस को खुद भी चेक करें)। नियमित रूप से इन चेकसम, चेकसम आने वाले संदेशों के खिलाफ अपने एफएसएम की जांच करने के लिए नोड्स प्राप्त करें, और उनके चेकसम को कोरम के चेकसम से मेल खाते हैं।

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

  • आप का समर्थन करने के लिए हार्डवेयर का उपयोग करें, लेकिन इतनी सावधानी से करें। उदाहरण के लिए, आप ईसीसी रैम प्राप्त कर सकते हैं, और ईसीसी त्रुटियों को ठीक करने के लिए इसके माध्यम से नियमित रूप से पढ़ / लिख सकते हैं (और यदि त्रुटि ठीक नहीं है तो घबराएं)। हालाँकि (मेमोरी से) स्टैटिक रैम DRAM की तुलना में आयनीकृत विकिरण के लिए अधिक सहिष्णु होता है, इसलिए इसके बजाय स्टैटिक DRAM का उपयोग करना बेहतर हो सकता है। 'मैं जो कुछ नहीं करूँगा' के तहत पहला बिंदु देखें।

मान लीजिए कि आपके पास एक दिन के भीतर किसी भी दिए गए नोड की विफलता का 1% मौका है, और आइए दिखाते हैं कि आप विफलताओं को पूरी तरह से स्वतंत्र बना सकते हैं। 5 नोड्स के साथ, आपको एक दिन में विफल होने के लिए तीन की आवश्यकता होगी, जो कि .00001% मौका है। अधिक, अच्छी तरह से, आप विचार प्राप्त करते हैं।

चीजें जो मैं नहीं करूंगा:

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

  • अपने स्वयं के एल्गोरिदम को रोल करें । लोग यह सामान पहले भी कर चुके हैं। उनके काम का उपयोग करें। दोष सहिष्णुता और वितरित एल्गोरिदम कठिन हैं। जहां संभव हो, अन्य लोगों के काम का उपयोग करें।

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

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





fault-tolerance