सीआरसी के लिए एक तेज़ विकल्प क्या है?

Question

मैं एक पीसी से dsPIC से कुछ डेटा ट्रांसमिशन कर रहा हूं और 512 बाइट्स के प्रत्येक ब्लॉक में 8-बिट सीआरसी कर रहा हूं ताकि यह सुनिश्चित हो सके कि कोई त्रुटि नहीं है। मेरे CRC कोड से मुझे लगभग 33KB / s प्राप्त होता है, इसके बिना मुझे 67KB / s मिलता है।

कुछ वैकल्पिक त्रुटि का पता लगाने वाले एल्गोरिदम का पता लगाने के लिए कि तेजी से क्या होगा?

Comments

सीआरसी को कैसे लागू किया जाता है? बिटवाइज़? फिर टेबल-आधारित पद्धति पर स्विच करें। Bytewise? 16 बिट्स (जो एक ही बार में दो बाइट्स पर काम करते हैं, लेकिन टेबल स्टोरेज 64KB ले लेंगे), टेबल साइज़ को बढ़ाने में शामिल स्पेस, जटिलता और टाइम ट्रेडऑफ़ पर विचार करें।

— ऐदन कलली

मेरे पास रैम पर केवल 16KB और ROM का 128KB है, इसलिए 64KB टेबल एक विकल्प नहीं है।

— अंजीर जुग

तो आप 256-बाइट टेबल का उपयोग कर रहे हैं? या बिटवाइज़ सीआरसी? यदि आप बिटवाइज़ कर रहे हैं, तो बाईटाइज़ (256-बाइट टेबल के साथ) 8 गुना तेज होगा।

— ऐदन कलली

वर्तमान में बिटवाइज़, मैं एक 256 टेबल की कोशिश

— करूंगा

67kb / s से 33kb / s? मुझे यकीन नहीं है कि आपके अन्य प्रसंस्करण में क्या शामिल है, लेकिन यह बहुत कुछ ओवरहेड की तरह लगता है, यहां तक ​​कि एक PIC के लिए भी। शायद आपके प्रदर्शन को बाधित करने वाली कुछ अन्य समस्याएं हैं?

— री मियासाका

Answer 1

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

अन्य विकल्पों के साथ सीआरसी की तुलना के लिए, मार्टिन थॉम्पसन द्वारा उत्कृष्ट उत्तर देखें ।

इसके साथ मदद करने का एक विकल्प pycrc है जो एक उपकरण है (अजगर ¹ में लिखा है ) जो crc मॉडल और एल्गोरिथ्म के दर्जनों संयोजनों के लिए C स्रोत कोड उत्पन्न कर सकता है । यह आपको विभिन्न संयोजनों का चयन और बेंचमार्किंग करके अपने स्वयं के अनुप्रयोग के लिए गति और आकार का अनुकूलन करने की अनुमति देता है। ^{1: अजगर 2.6 या बाद के संस्करण की आवश्यकता है।}

यह crc-8 मॉडल का समर्थन करता है , लेकिन यह भी समर्थन करता है crc-5, crc-16और crc-32दूसरों के बीच। एल्गोरिदम के रूप में , यह समर्थन करता है bit-by-bit, bit-by-bit-fastऔर table-driven।

उदाहरण के लिए (संग्रह को डाउनलोड करना):

$ wget --quiet http://sourceforge.net/projects/pycrc/files/pycrc/pycrc-0.8/pycrc-0.8.tar.gz/download
$ tar -xf pycrc-0.8.tar.gz
$ cd pycrc-0.8
$ ./pycrc.py --model=crc-8 --algorithm=bit-by-bit      --generate c -o crc8-byb.c
$ ./pycrc.py --model=crc-8 --algorithm=bit-by-bit-fast --generate c -o crc8-bybf.c
$ ./pycrc.py --model=crc-8 --algorithm=table-driven    --generate c -o crc8-table.c
$ ./pycrc.py --model=crc-16 --algorithm=table-driven   --generate c -o crc16-table.c
$ wc *.c
   72   256  1790 crc8-byb.c
   54   190  1392 crc8-bybf.c
   66   433  2966 crc8-table.c
  101   515  4094 crc16-table.c
  293  1394 10242 total

आप सिंगल बाइट लुक-अप के बजाय 256 बाइट लुक-अप टेबल के साथ ड्यूल निबल लुकअप (16 बाइट लुक-अप टेबल के साथ) का उपयोग करके निर्दिष्ट कर सकते हैं।

उदाहरण के लिए (गिट रिपॉजिटरी की क्लोनिंग):

$ git clone http://github.com/tpircher/pycrc.git
$ cd pycrc
$ git branch
* master
$ git describe
v0.8-3-g7a041cd
$ ./pycrc.py --model=crc-8 --algorithm=table-driven --table-idx-width=4 --generate c -o crc8-table4.c
$ wc crc8-table4.c
  53  211 1562 crc8-table4.c

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

---

Pycrc Git भंडार पर है GitHub के रूप में अपनी है, समस्या ट्रैकर , लेकिन यह भी से डाउनलोड किया जा सकता sourceforge ।

Comments

मुझे विश्वास नहीं है कि PIC के लिए चीजें लिखने वाले अधिकांश लोग C का उपयोग कर रहे हैं, लेकिन ऐसा हो सकता है।

— बिली ओनली

@ बिली - सच? मुझे नहीं लगता कि मैं व्यावसायिक रूप से PIC के लिए विकसित करने वाले किसी व्यक्ति के साथ आया हूं जो सी का उपयोग नहीं कर रहा था। मेरे पास निश्चित रूप से इन दिनों कोडांतरक के लिए धैर्य नहीं है और अच्छी तरह से संरचित सी सुंदर कॉम्पैक्ट को समाप्त कर सकता है।

— मार्क बूथ

मैं एक dsPIC उपयोग कर रहा हूँ और मैं सी का उपयोग कर रहा

— FigBug

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

— मार्क बूथ

यहाँ pyCrc के लिए एक और वोट। विभिन्न बाधाओं के साथ विभिन्न परियोजनाओं में इसका उपयोग करना और यह बहुत अच्छा है।

— विक्की

Answer 2

सरल एक बिट समता (मूल रूप से डेटा को अपने आप से अधिक से अधिक XOR करना) लगभग उतना ही तेज़ है जितना कोई प्राप्त कर सकता है। आप हालांकि CRC की त्रुटि जांच में बहुत अधिक चूक जाते हैं।

छद्मकोश में:

char checksum = 0;
for each (char c in buffer)
{
    checksum ^= c;
    SendToPC(c);
}
SendToPc(checksum);

Comments

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

— जल्दी से

@quickly: मुझे नहीं लगता कि उन दोनों के बीच कोई महत्वपूर्ण अंतर है - न ही विधि सभी को यह अच्छा आश्वासन देती है कि चीजें दूषित नहीं हुई हैं। यदि ऐड टार्गेट आर्किटेक्चर पर तेजी से होता है, तो इसके बजाय सभी उपयोग करें।

— बिली ओनेल

मुझे याद आया: ADD और XOR के बीच प्रमुख अंतर यह है कि इसमें कई बिट त्रुटियों की कम पहचान होती है। बाइट्स की एक धारा के मामले में, XOR के उपयोग से समान स्थिति में त्रुटियां रद्द कर दी जाती हैं। एडीडी का उपयोग करते समय, एक चेकसम बाइट के माध्यम से बिट्स के प्रसार का मतलब है कि यह मामला अधिक पता लगाने योग्य है। (हालांकि, बाइट्स की धारा के माध्यम से फैले हुए विभिन्न बिट्स में कई बिट त्रुटियां कम पता लगाने योग्य होने की संभावना है - समय पर परिस्थितियों के आधार पर)। इस तरह की कोई भी चेकसम व्यवस्था कई-बिट त्रुटियों के लिए TERRIBLE है, इसलिए यह एक काफी मामूली तर्क है।

— जल्‍दी से जल्‍दी_जूल

XOR CRC की तुलना में बहुत कम मददगार है।

@ Thorbjørn: मेरा मानना ​​है कि मैंने अपने उत्तर में स्वीकार किया है। :)

— बिली ओनली

Answer 3

एक एम्बेडेड संदर्भ में विभिन्न चेकसम और सीआरसी के प्रदर्शन की तुलना करने वाला वास्तव में अच्छा पेपर:

एंबेडेड नेटवर्क के लिए चेकसम की प्रभावशीलता

निष्कर्ष से कुछ उद्धरण (अनिर्धारित त्रुटि संभावनाओं के अपने अध्ययन के आधार पर):

जब फट त्रुटियों हावी है

XOR, दो के पूरक जोड़, और CRC चेकसम एक के पूरक जोड़, फ्लेचर और एडलर चेकसम की तुलना में बेहतर त्रुटि पहचान प्रदर्शन प्रदान करते हैं।

अन्य अनुप्रयोगों में

एक "अच्छा" सीआरसी बहुपद, जब भी संभव हो, त्रुटि का पता लगाने के उद्देश्यों के लिए उपयोग किया जाना चाहिए

अगर गणना लागत बहुत विवश है

(आपके मामले में), उपयोग (प्रभावशीलता के क्रम में):

• फ्लेचर का चेकसम
• किसी का पूरक
• दो के पूरक इसके अलावा

अन्य उद्धरण:

फ्लेचर चेकसम की एडलर चेकसम की तुलना में कम कम्प्यूटेशनल लागत है और, लोकप्रिय धारणा के विपरीत, अधिकांश स्थितियों में भी अधिक प्रभावी है।

तथा

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

Comments

एक बोनस के रूप में, एक फ्लेचर चेकसम को लागू करना बहुत आसान है।

— रबरडक

Answer 4

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

से विकिपीडिया पृष्ठ :

एक एडलर -32 चेकसम दो 16-बिट चेकसम ए और बी की गणना करके और 32-बिट पूर्णांक में अपने बिट्स को समेट कर प्राप्त किया जाता है। A स्ट्रिंग के साथ-साथ सभी बाइट्स का योग है, और B प्रत्येक चरण से A के व्यक्तिगत मानों का योग है।

एडलर -32 रन की शुरुआत में, A को 1, B से 0. तक आरम्भ किया जाता है। sums को modulo 65521 (2 ^ 16 या 65536 से छोटा सबसे बड़ा अभाज्य संख्या) किया जाता है। बाइट्स नेटवर्क ऑर्डर (बड़े एंडियन) में संग्रहीत हैं, बी दो सबसे महत्वपूर्ण बाइट्स पर कब्जा कर रहे हैं।

समारोह के रूप में व्यक्त किया जा सकता है

 A = 1 + D1 + D2 + ... + Dn (mod 65521)
 B = (1 + D1) + (1 + D1 + D2) + ... + (1 + D1 + D2 + ... + Dn) (mod 65521)
   = n×D1 + (n-1)×D2 + (n-2)×D3 + ... + Dn + n (mod 65521)

 Adler-32(D) = B × 65536 + A

जहाँ D बाइट्स की स्ट्रिंग है जिसके लिए चेकसम की गणना की जानी है, और n की लंबाई D है।

Comments

ध्यान दें कि Adler32 डेटा के कम रनों के लिए लगभग बेकार है। लगभग 180 बाइट्स तक, यह कई टकराव पैदा करता है।

— ग्रेफेड

+1 - एक सीआरसी और सरल बिट समता के बीच एक उचित मध्य मैदान।

— बिली ओनली

@ ग्रेफेड - फिगरबग ने 512 बाइट ब्लॉक का उपयोग किया है, इसलिए यह ओपी के लिए समस्या नहीं होनी चाहिए। हालांकि अन्य आवश्यकताओं वाले लोगों के लिए यह अच्छा है।

— मार्क बूथ

Answer 5

मुझे कुछ भी ज्ञात नहीं है जो CRC के रूप में त्रुटि का पता लगाने में उतना ही प्रभावी है और तेजी से - अगर वहाँ थे, तो लोग इसके बजाय इसका उपयोग कर रहे होंगे।

आप एक साधारण चेकसम की कोशिश कर सकते हैं, लेकिन त्रुटियों का पता लगाने की संभावना बहुत कम है।

Comments

मैं गति के लिए एक प्रभाव छोड़ने को तैयार हूँ।

— 21

Answer 6

वैसे चेकसम लॉजिक अपने आप में अच्छा है और लोग तेज एल्गोरिदम की मदद कर सकते हैं।

यदि आप अपने घटक की गति में सुधार करना चाहते हैं, तो आपको सत्यापन घटक से स्थानांतरण घटक को अलग करने के लिए अपनी समग्र तकनीक को बदलने की आवश्यकता हो सकती है।

यदि आपके पास दो स्वतंत्र आइटम (विभिन्न थ्रेड्स पर) के रूप में हैं, तो आप हस्तांतरण की अपनी पूरी गति प्राप्त कर सकते हैं और केवल असफल पैकेट को फिर से भेज सकते हैं।

एल्गोरिथम कुछ इस तरह दिखाई देगा:

• सर्वर ज्ञात पैकेट आकार (1K विखंडू) को तोड़ता है। उन्हें "भेजे जाने वाले" की कतार में रखता है।
• प्रत्येक पैकेट को 16 या 32 बिट आईडी और उसके चेकसम के साथ भेजा जाता है।
• ग्राहक प्रत्येक पैकेट प्राप्त करता है और इसे संसाधित करने के लिए एक कतार में रखता है।
• एक अलग थ्रेड पर ग्राहक एक बार में एक पैकेट लेता है, सत्यापन करता है।
  • सफलता मिलने पर इसे पैकेट के अंतिम संग्रह (आईडी क्रम में) से जोड़ा जा रहा है
  • विफल होने पर यह विफल आईडी को सर्वर पर वापस भेज देता है, जो उस पैकेट को नाराज करने के लिए कतार में खड़ा कर देता है।
• एक बार जब आप पैकेट को पुनः प्राप्त और सत्यापित कर लेते हैं और आपके पास सही seununce में ID होती है (1 से शुरू होती है) तो आप इन्हें डिस्क पर लिखना शुरू कर सकते हैं (या कभी भी आवश्यक हो)।

यह आपको उच्चतम संभव गति से ट्रसमिट करने देगा और यदि आप अपने पैकेट के आकार के साथ खेलते हैं तो आप ऑप्टिमियम फेल रेट वीएस वैलिडेट / रिसेंड रेट को काम कर सकते हैं।

Answer 7

चेकसम पारंपरिक हैं

(कम करें # '+ स्ट्रीम)

XOR जैसा कि ऊपर दिया गया है, वैसे ही काम करेगा

(# XOR स्ट्रीम कम करें)

थोड़ी और विस्तृत (धीमी) योजना सीरियल कनेक्शन के लिए मानक समता की जाँच है।

इस स्तर पर, आप गति के लिए शुद्धता का व्यापार कर रहे हैं। ये कभी-कभार असफल हो जाएंगे।

अगले सबसे परिष्कृत स्तर पर, आप कुछ crc / हैश प्रकार के सामान का उपयोग कर सकते हैं।

एक अन्य डिजाइन धारा के लिए उपयोग किए जाने वाले ब्लॉक के आकार को बढ़ाने के लिए होगा।

आपके पास अपने एल्गोरिथ्म चयन और ब्लॉक आकार के मापदंडों को ट्यून करने के लिए वास्तविक त्रुटि दर का अनुमान होना चाहिए।