🚃 ◻️ 🔀 फ्लैश रिकॉर्डिंग को गति देने का प्रयास 👨🏼‍🔧 🚡 🔞

परिचय

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

विचार का सामान्य विवरण

शुरू करने के लिए, यह विचार करने योग्य है: फ़ाइल क्या है? मेरे विचार सरल थे: फ़ाइल बाइट्स का एक क्रम है। एक बाइट बिट्स का एक क्रम है।
अगला, आपको यह विचार करना चाहिए कि फ्लैश की व्यवस्था कैसे की जाती है। शौकिया दृष्टिकोण यह है: कोशिकाओं का एक मैट्रिक्स है (जहां तक मुझे पता है: 1 सेल - 1 क्षेत्र-प्रभाव ट्रांजिस्टर)। एक सेल में, आप 1 बिट जानकारी लिख सकते हैं। रिकॉर्डिंग की जानकारी की गति उस गति पर निर्भर करती है जिस पर नियंत्रक सेल को वांछित स्थिति में सेट कर सकता है।
हम आगे बढ़ते हैं और समझते हैं कि सेल में जानकारी का हिस्सा नहीं लिखने पर ही गति बढ़ाना संभव होगा। पहली नज़र में अंतिम कथन बेतुका लगता है, लेकिन आइए फ़ाइल की संरचना को याद करते हैं। वास्तव में, जानकारी कुछ संख्याओं का एक यादृच्छिक सेट है। और जहां मौका है, वहां संभावना है। फिर एक शौकिया मुझ में फिर से जाग उठा, और मैंने मान लिया कि फ़ाइल में नंबर 1 और 0 उसी के बारे में थे, और उनकी उपस्थिति की संभावना = 0.5 थी।
लेकिन क्या होगा अगर, रिकॉर्डिंग के दौरान, हम उन कोशिकाओं को छोड़ देते हैं जो उस अवस्था में सेट होती हैं, जिसकी हमें ज़रूरत होती है? इसलिए लिखने की गति थोड़ी बढ़नी चाहिए। ऐसा करने के लिए, हमें उन कोशिकाओं को राज्य में स्थापित करने की आवश्यकता है जिन्हें हम जानते हैं। मैंने 1 और 0 को बारी-बारी से आज़माया।

कार्यान्वयन

कार्यान्वयन के लिए, हमें कुछ बातें जानने की आवश्यकता है:

फ्लैश ड्राइव लिखें गति
फ्लैश ड्राइव से गति पढ़ें (वास्तव में जरूरत नहीं है, लेकिन आप पूरी तस्वीर के लिए पता लगा सकते हैं)
बिट तुलना की गति

आगे बढ़ो।

यादृच्छिक फ़ाइल पीढ़ी

हम एक छोटा प्रोग्राम लिखेंगे जो एक यादृच्छिक 1MB फ़ाइल उत्पन्न करेगा। इसके बाद हम कॉकटेल सी और सी ++ (ठीक है, यह हुआ) का उपयोग करेंगे।

#include <iostream> #include <fstream> #include <stdlib.h> #include <time.h> #define fsize 1048576 using namespace std; int main(){ fstream f; f.open("rand_file", ios::out); srand(time(0)); for(int i=0; i<fsize; ++i){ f<<(char)(rand()%255); } f.close(); return 0; }

मुझे लगता है कि यहां सब कुछ स्पष्ट है। हम यादृच्छिक बाइट्स उत्पन्न करते हैं और उन्हें एक फ़ाइल में लिखते हैं।

गति माप

फिर से हम संकलक को गर्म करना शुरू करते हैं, और, हम इसे निम्नलिखित कोड खिलाते हैं:

 #include <iostream> #include <fstream> #include <sys/time.h> #include <fcntl.h> using namespace std; inline long long gettimeus() { struct timeval tv; gettimeofday( &tv, NULL ); return (long long) tv.tv_sec * 1000000LL + (long long) tv.tv_usec; } int main(int argc, char **argv) { int in = open(argv[1], O_RDONLY); int out = open(argv[2], O_WRONLY | O_CREAT); int size = lseek(in, 0, SEEK_END); lseek(in, 0, SEEK_SET); if (size > 0){ char *fin = new char[size]; long long tmIn = gettimeus(); for(int i=0; i<size; ++i) read (in, &(fin[i]), 1); tmIn = gettimeus() - tmIn; cout<<"Time read: "<<tmIn<<endl; long long tmOut = gettimeus(); for(int i=0; i<size; ++i) write(out, &(fin[i]), 1); tmOut = gettimeus() - tmOut; cout<<"Time write: "<<tmOut<<endl; long long tmIF = gettimeus(); int s = size*8; for(int i=0; i<s; ++i) if (true == false); tmIF = gettimeus() - tmIF; cout<<"Time if: "<<tmIF<<endl; delete [] fin; } close(in); close(out); return 0; }

यहाँ यह कुछ बिंदुओं को स्पष्ट करने के लायक है:
गेटटाइम () फ़ंक्शन गिनती के समय के लिए आवश्यक है, लेकिन विंडोज उपयोगकर्ता सबसे अधिक काम नहीं करेंगे, क्योंकि उनके पास sys / time.h नहीं है। लिनक्स वितरण के भाग्यशाली मालिकों को किसी भी संकलन की कठिनाइयों को महसूस नहीं करना चाहिए। अगला, थोड़ा कोड। कार्यक्रम में दो तर्क दिए गए हैं:
1. पढ़ने के लिए फ़ाइल।
2. रिकॉर्डिंग के लिए फ़ाइल।
और वैकल्पिक रूप से एक फ़ाइल को पढ़ने की कोशिश कर रहा है, और दूसरी फ़ाइल पर लिख रहा है, साथ ही साथ इन कार्यों पर खर्च किए गए समय को मापता है। इन उद्देश्यों के लिए, सिस्टम रीड रीड () और राइट () का उपयोग किया जाता है। खैर, बोनस के रूप में, तुलना का समय मापा जा रहा है।
कार्यक्रम को 10 बार चलाएं, और प्राप्त मूल्यों को औसत करें:

पढ़ें	लिखें	अगर
296,127	1,082,888.7	24024.9

जैसा कि एक उम्मीद करता है, सबसे तेज़ ऑपरेशन तुलना है, और सबसे धीमी रिकॉर्डिंग है। आगे की गणना के लिए, हम समय की अन्य इकाइयों के लिए आगे बढ़ेंगे। ऐसा करने के लिए, हम तुलना के समय हर समय विभाजित करते हैं। नतीजतन, हम प्राप्त करते हैं:
तुलना - १।
रिकॉर्ड - 45.07।
पढ़ना - 12.33।
वह सब है। अब कुछ भी हमें अनुकरण शुरू करने से रोकता है।

प्रदर्शन रेटिंग

मूल्यांकन का विचार सरल है: हम फ़ाइल को स्मृति में स्थानांतरित करते हैं, हम प्रत्येक बाइट को थोड़ा प्रतिनिधित्व में स्थानांतरित करते हैं। और हम डब के समय की गिनती शुरू करते हैं।

 #include <iostream> #include <fstream> #include <sys/time.h> #include <fcntl.h> #include <stdio.h> #include <string.h> using namespace std; const double WRITE = 45.07; const double READ = 12.33; const double IF = 1.0; bool *translateToBitArray(const char *array, int size); int main(int argc, char **argv) { if (argc > 1){ int in = open(argv[1], O_RDONLY); int size = lseek(in, 0, SEEK_END); lseek(in, 0, SEEK_SET); if (size > 0){ char *fin = new char[size]; bool *bFOut = new bool[size*8]; //    for(int i=0; i<size; ++i) read (in, &(fin[i]), 1); bFOut[0] = true; for(int i=1; i<size*8; ++i) //     bFOut[i] = !bFOut[i-1]; bool *bArr = translateToBitArray(fin, size);//     double timeLinear = 0; double timeOpt = 0; timeLinear = WRITE*size*8; //    bool flag = bFOut[0]; //  for(int i=0; i<size*8; ++i){ //  timeOpt += IF; if (bArr[i] != flag){ bFOut[i] = bArr[i]; timeOpt += WRITE; } flag = !flag; } // flag = false; for(int i=0; i<size*8; ++i) if (bArr[i] != bFOut[i]){ flag = true; break; } if (flag) printf("ERROR\n"); printf("Time linear = %.6lf\nTime opt = %.6lf\n",timeLinear, timeOpt); delete [] fin; delete [] bFOut; } close(in); } return 0; } bool *translateToBitArray(const char *array, int size) { bool *bArr = new bool[size*8]; bool *tmp = new bool[8]; int pos = 0; for(int i=0; i<size; ++i){ unsigned char c = array[i]; int ppp = 8; fill_n(tmp, 8, 0); while (c != 0){ tmp[ppp--] = (c & 1); c = c >> 1; } memcpy(&(bArr[pos]), tmp, 8); pos += 8; } delete [] tmp; return bArr; }

कोई जाँच नहीं, कोई सुराग नहीं। अगर यह काम करता है - ठीक है, अगर नहीं - हम बाहर उड़ते हैं और यह बात है। हम विभिन्न फ़ाइलों (पहले यादृच्छिक, और फिर वास्तविक) पर 10 बार प्रोग्राम चलाते हैं।

मॉडलिंग के परिणाम

नतीजतन, हम साधारण रिकॉर्डिंग के संबंध में ~ 1.71 गुना का त्वरण प्राप्त करते हैं।

मरहम में उड़ना

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

निष्कर्ष

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

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

कुछ इस तरह। आपकी टिप्पणियों की प्रतीक्षा है।

फ्लैश रिकॉर्डिंग को गति देने का प्रयास