Node.js में कुशल मेमोरी हैंडलिंग

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



सामग्री, जिसका अनुवाद आज हम प्रकाशित करते हैं, वह Node.js. के वातावरण में स्मृति के साथ प्रभावी कार्य पर ध्यान केंद्रित करेगी। विशेष रूप से, धाराएं, बफ़र्स और pipe() स्ट्रीम विधि जैसी अवधारणाओं पर यहां चर्चा की जाएगी। प्रयोगों में Node.js v8.12.0 का उपयोग किया जाएगा। उदाहरण कोड वाला एक भंडार यहां पाया जा सकता है ।

कार्य: एक बड़ी फ़ाइल की प्रतिलिपि बनाना

यदि किसी को Node.js में फ़ाइलों की प्रतिलिपि बनाने के लिए एक कार्यक्रम बनाने के लिए कहा जाता है, तो सबसे अधिक संभावना है कि वह तुरंत नीचे दिखाए गए जैसे कुछ लिख देगा। हम इस कोड वाली फाइल का नाम basic_copy.js ।

 const fs = require('fs'); let fileName = process.argv[2]; let destPath = process.argv[3]; fs.readFile(fileName, (err, data) => {   if (err) throw err;   fs.writeFile(destPath || 'output', data, (err) => {       if (err) throw err;   });     console.log('New file has been created!'); }); 

यह प्रोग्राम किसी फ़ाइल को किसी दिए गए नाम के साथ पढ़ने और लिखने के लिए बनाता है और इसे पढ़ने के बाद फ़ाइल डेटा लिखने की कोशिश करता है। छोटी फ़ाइलों के लिए, यह दृष्टिकोण काम कर रहा है।

मान लीजिए कि हमारे एप्लिकेशन को डेटा बैकअप प्रक्रिया के दौरान एक बड़ी फ़ाइल (हम 4 जीबी से बड़ी "बड़ी फ़ाइलों पर विचार करेंगे" की प्रतिलिपि बनाने की आवश्यकता है। उदाहरण के लिए, मेरे पास 7.4 GB आकार की एक वीडियो फ़ाइल है, जिसे मैं ऊपर वर्णित कार्यक्रम का उपयोग करके, अपनी वर्तमान निर्देशिका से Documents निर्देशिका में कॉपी करने का प्रयास करूंगा। यहाँ प्रतिलिपि शुरू करने का आदेश दिया गया है:

 $ node basic_copy.js cartoonMovie.mkv ~/Documents/bigMovie.mkv 

उबंटू में, इस कमांड को निष्पादित करने के बाद, बफर ओवरफ्लो से संबंधित एक त्रुटि संदेश प्रदर्शित किया गया था:

 /home/shobarani/Workspace/basic_copy.js:7   if (err) throw err;            ^ RangeError: File size is greater than possible Buffer: 0x7fffffff bytes   at FSReqWrap.readFileAfterStat [as oncomplete] (fs.js:453:11) 

जैसा कि आप देख सकते हैं, इस तथ्य के कारण फ़ाइल रीड ऑपरेशन विफल हो गया कि Node.js केवल 2 जीबी डेटा को बफर में पढ़ने की अनुमति देता है। इस सीमा को कैसे पार करें? संचालन करते समय जो गहन रूप से I / O सबसिस्टम का उपयोग करते हैं (फ़ाइलों की प्रतिलिपि बनाना, उन्हें संसाधित करना, उन्हें संपीड़ित करना), सिस्टम की क्षमताओं और स्मृति से जुड़ी सीमाओं को ध्यान में रखना आवश्यक है।

Node.js में स्ट्रीम और बफर

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

▍Bufery

Buffer ऑब्जेक्ट को प्रारंभ करके एक बफर बनाया जा सकता है।

 let buffer = new Buffer(10); // 10 -    console.log(buffer); //  <Buffer 00 00 00 00 00 00 00 00 00 00> 

8 वें की तुलना में Node.js के संस्करणों में, बफ़र्स बनाने के लिए निम्न निर्माण का उपयोग करना सबसे अच्छा है:

 let buffer = new Buffer.alloc(10); console.log(buffer); //  <Buffer 00 00 00 00 00 00 00 00 00 00> 

यदि हमारे पास पहले से ही कुछ डेटा है, जैसे कि एक सरणी या कुछ इसी तरह, तो इस डेटा के आधार पर एक बफर बनाया जा सकता है।

 let name = 'Node JS DEV'; let buffer = Buffer.from(name); console.log(buffer) //  <Buffer 4e 6f 64 65 20 4a 53 20 44 45 5> 

बफ़र के पास ऐसे तरीके हैं जो आपको उनमें "देखने" की अनुमति देते हैं और यह पता toJSON() हैं कि क्या डेटा है - ये toString() और toJSON() विधियाँ हैं।

हम, कोड को अनुकूलित करने की प्रक्रिया में, स्वयं बफ़र्स नहीं बनाएंगे। Node.js स्ट्रीम या नेटवर्क सॉकेट्स के साथ काम करते समय इन डेटा संरचनाओं को स्वचालित रूप से बनाता है।

▍ धाराएँ

धाराओं, अगर हम विज्ञान कथा की भाषा की ओर रुख करते हैं, तो पोर्टल्स के साथ अन्य दुनिया की तुलना की जा सकती है। चार प्रकार की धाराएँ हैं:

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

हमें स्ट्रीम की आवश्यकता है क्योंकि Node.js में स्ट्रीम API का महत्वपूर्ण लक्ष्य, और विशेष रूप से stream.pipe() विधि, डेटा बफरिंग को स्वीकार्य स्तरों तक सीमित करना है। ऐसा इसलिए किया जाता है ताकि स्रोतों और डेटा के रिसीवर के साथ काम करना जो विभिन्न प्रसंस्करण गति में भिन्न हो, उपलब्ध मेमोरी को ओवरफ्लो नहीं करेंगे।

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


धाराएँ और बफ़र (Node.js प्रलेखन पर आधारित)

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

समाधान 1. स्ट्रीम का उपयोग करके फ़ाइलों को कॉपी करना

एक बड़ी फ़ाइल की प्रतिलिपि बनाने की समस्या के समाधान पर विचार करें, जिसके बारे में हमने ऊपर बात की थी। यह समाधान दो धागों पर आधारित हो सकता है और इस तरह दिखेगा:

• हमें उम्मीद है कि डेटा का अगला टुकड़ा पढ़ने के लिए स्ट्रीम में दिखाई देगा।
• हम प्राप्त आंकड़ों को रिकॉर्डिंग के लिए स्ट्रीम में लिखते हैं।
• हम कॉपी ऑपरेशन की प्रगति की निगरानी करते हैं।

हम उस प्रोग्राम को कॉल करेंगे जो इस विचार को कार्यान्वित करता है streams_copy_basic.js । यहाँ उसका कोड है:

 /*         . : Naren Arya */ const stream = require('stream'); const fs = require('fs'); let fileName = process.argv[2]; let destPath = process.argv[3]; const readable = fs.createReadStream(fileName); const writeable = fs.createWriteStream(destPath || "output"); fs.stat(fileName, (err, stats) => {   this.fileSize = stats.size;   this.counter = 1;   this.fileArray = fileName.split('.');     try {       this.duplicate = destPath + "/" + this.fileArray[0] + '_Copy.' + this.fileArray[1];   } catch(e) {       console.exception('File name is invalid! please pass the proper one');   }     process.stdout.write(`File: ${this.duplicate} is being created:`);     readable.on('data', (chunk)=> {       let percentageCopied = ((chunk.length * this.counter) / this.fileSize) * 100;       process.stdout.clearLine();  //          process.stdout.cursorTo(0);       process.stdout.write(`${Math.round(percentageCopied)}%`);       writeable.write(chunk);       this.counter += 1;   });     readable.on('end', (e) => {       process.stdout.clearLine();  //          process.stdout.cursorTo(0);       process.stdout.write("Successfully finished the operation");       return;   });     readable.on('error', (e) => {       console.log("Some error occurred: ", e);   });     writeable.on('finish', () => {       console.log("Successfully created the file copy!");   });  }); 

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

हम यहां ईवेंट तंत्र का उपयोग करते हैं, विशेष रूप से, हम निम्नलिखित घटनाओं की सदस्यता लेने के बारे में बात कर रहे हैं:

• data - data एक टुकड़ा पढ़ते समय कहा जाता है।
• end - जब डेटा को रीड स्ट्रीम से पढ़ा जाता है।
• error - अगर डेटा पढ़ते समय कोई त्रुटि होती है, तो उसे कहा जाता है

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

 $ time node streams_copy_basic.js cartoonMovie.mkv ~/Documents/4kdemo.mkv 

हालाँकि, एक समस्या है। विभिन्न प्रक्रियाओं द्वारा सिस्टम संसाधनों के उपयोग के डेटा को देखकर इसकी पहचान की जा सकती है।


सिस्टम संसाधन उपयोग डेटा

ध्यान दें कि node प्रक्रिया, 88% फ़ाइल की प्रतिलिपि बनाने के बाद, 4.6 जीबी मेमोरी लेती है। यह बहुत कुछ है, स्मृति के ऐसे हैंडलिंग अन्य कार्यक्रमों के काम में हस्तक्षेप कर सकते हैं।

Consumption अत्यधिक स्मृति खपत के कारण

पिछले चित्रण से डिस्क पर डेटा पढ़ने और डेटा लिखने की गति पर ध्यान दें ( Disk Read और Disk Write कॉलम)। अर्थात्, यहाँ आप निम्न संकेतक देख सकते हैं:

 Disk Read: 53.4 MiB/s Disk Write: 14.8 MiB/s 

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

मेरे कंप्यूटर पर, यह कार्यक्रम 3 मिनट 16 सेकंड तक चला। इसकी प्रगति के बारे में जानकारी यहाँ दी गई है:

 17.16s user 25.06s system 21% cpu 3:16.61 total 

समाधान 2. धाराओं का उपयोग करके फ़ाइलों को कॉपी करना और डेटा पढ़ने और लिखने की गति की स्वचालित ट्यूनिंग के साथ

उपरोक्त समस्या से निपटने के लिए, हम प्रोग्राम को संशोधित कर सकते हैं ताकि फ़ाइल की प्रतिलिपि बनाने के दौरान, पढ़ने और लिखने की गति स्वचालित रूप से कॉन्फ़िगर हो जाए। इस तंत्र को वापस दबाव कहा जाता है। इसका उपयोग करने के लिए, हमें कुछ विशेष करने की आवश्यकता नहीं है। यह पर्याप्त है, pipe() विधि का उपयोग करके, रीड स्ट्रीम को राइट स्ट्रीम से कनेक्ट करने के लिए, और Node.js स्वचालित रूप से डेटा ट्रांसफर गति को समायोजित करेगा।

इस प्रोग्राम को streams_copy_efficient.js कॉल करें। यहाँ उसका कोड है:

 /*          pipe(). : Naren Arya */ const stream = require('stream'); const fs = require('fs'); let fileName = process.argv[2]; let destPath = process.argv[3]; const readable = fs.createReadStream(fileName); const writeable = fs.createWriteStream(destPath || "output"); fs.stat(fileName, (err, stats) => {   this.fileSize = stats.size;   this.counter = 1;   this.fileArray = fileName.split('.');     try {       this.duplicate = destPath + "/" + this.fileArray[0] + '_Copy.' + this.fileArray[1];   } catch(e) {       console.exception('File name is invalid! please pass the proper one');   }     process.stdout.write(`File: ${this.duplicate} is being created:`);     readable.on('data', (chunk) => {       let percentageCopied = ((chunk.length * this.counter) / this.fileSize) * 100;       process.stdout.clearLine();  //          process.stdout.cursorTo(0);       process.stdout.write(`${Math.round(percentageCopied)}%`);       this.counter += 1;   });   readable.on('error', (e) => {       console.log("Some error occurred: ", e);   });     writeable.on('finish', () => {       process.stdout.clearLine();  //          process.stdout.cursorTo(0);       process.stdout.write("Successfully created the file copy!");   });     readable.pipe(writeable); //  !  }); 

इस कार्यक्रम और पिछले एक के बीच मुख्य अंतर यह है कि डेटा टुकड़ों को कॉपी करने के लिए कोड को निम्नलिखित पंक्ति से बदल दिया गया है:

 readable.pipe(writeable); //  ! 

यहां होने वाली हर चीज के दिल में pipe() विधि है। यह पढ़ने और लिखने की गति को नियंत्रित करता है, जो इस तथ्य की ओर जाता है कि स्मृति अब अतिभारित नहीं है।

प्रोग्राम चलाएं।

 $ time node streams_copy_efficient.js cartoonMovie.mkv ~/Documents/4kdemo.mkv 

हम उसी विशाल फ़ाइल को कॉपी कर रहे हैं। अब देखते हैं कि मेमोरी के साथ और डिस्क के साथ काम कैसे दिखता है।


पाइप () का उपयोग करके, पढ़ने और लिखने की गति स्वचालित रूप से कॉन्फ़िगर की जाती है

अब हम देखते हैं कि node प्रक्रिया में केवल 61.9 एमबी मेमोरी की खपत होती है। यदि आप डिस्क उपयोग के डेटा को देखते हैं, तो आप निम्नलिखित देख सकते हैं:

 Disk Read: 35.5 MiB/s Disk Write: 35.5 MiB/s 

पीठ के दबाव तंत्र के लिए धन्यवाद, पढ़ने और लिखने की गति अब हमेशा एक दूसरे के बराबर होती है। इसके अलावा, नया कार्यक्रम पुराने की तुलना में 13 सेकंड तेज चलता है।

 12.13s user 28.50s system 22% cpu 3:03.35 total 

pipe() विधि का उपयोग करके, हम कार्यक्रम निष्पादन समय को कम करने और स्मृति खपत को 98.68% तक कम करने में सक्षम थे।

इस स्थिति में, डेटा रीड स्ट्रीम द्वारा बनाए गए बफर का आकार 61.9 एमबी है। हम इस आकार को अच्छी तरह से सेट कर सकते हैं, डेटा पढ़ने के लिए स्ट्रीम की read() विधि का उपयोग कर:

 const readable = fs.createReadStream(fileName); readable.read(no_of_bytes_size); 

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

परिणाम

इस लेख का एक लक्ष्य यह प्रदर्शित करना था कि Node.js पर खराब कार्यक्रमों को लिखना कितना आसान है, भले ही यह मंच डेवलपर के लिए शानदार API प्रदान करता है। इस एपीआई पर कुछ ध्यान देने के साथ, आप सर्वर-साइड सॉफ्टवेयर परियोजनाओं की गुणवत्ता में सुधार कर सकते हैं।

प्रिय पाठकों! आप Node.js में बफ़र और थ्रेड के साथ कैसे काम करते हैं?