👖 ↙️ 👩‍🚒 उदाहरण के रूप में फायरबर्ड का उपयोग करके बनाम बनाम सिंक 🎼 😼 🧑🏼‍🤝‍🧑🏻

इस प्रकाशन में, मैंने खुद को कई लक्ष्य निर्धारित किए:

NodeJS में फायरबर्ड डेटाबेस के साथ काम करने के लिए विभिन्न प्रोग्रामिंग शैलियों की तुलना करें;
सबसे उत्पादक विकल्प खोजें;
NodeJS में फायरबर्ड का उपयोग शुरू करने वालों के लिए कार्रवाई करने के लिए एक गाइड प्राप्त करें।

फिर बहुत सारे कोड ...

परीक्षण कार्य बहुत सरल लगता है:
वापसी परिणाम

select * from rdb$relations

JSON प्रारूप में। मेरे परीक्षण के आधार पर यह आकार में लगभग 19 kb का उत्तर होगा।

हम इस कार्य को कार्यान्वित करने के लिए विभिन्न विकल्प लिखेंगे और, अपाचे बेंचमार्क का उपयोग करते हुए, हम सबसे अच्छा विकल्प पाएंगे। हम निम्नलिखित कमांड के साथ प्रदर्शन का परीक्षण करेंगे:

  ab -n 10000 -c 5 http: // localhost: 1337 /

मैं बेंचमार्क के संपूर्ण निष्कर्ष का हवाला नहीं दूंगा ताकि लेख को अधिभार न डालें। प्रति सेकंड (RPS) संसाधित अनुरोधों की औसत संख्या अधिकांश मामलों में निष्कर्ष निकालने के लिए पर्याप्त होगी।

तो, चलो सबसे सरल विकल्प से शुरू करते हैं, जब एक्सेस लाइब्रेरी के सभी कॉल समकालिक होते हैं:

 var cfg = require("../config").cfg; var fb = require('../../firebird'); var util = require('util'); var http = require('http'); http.createServer(function (req, res) { res.writeHead(200, {'Content-Type': 'text/plain'}); var con = fb.createConnection(); con.connectSync(cfg.db, cfg.user, cfg.password, cfg.role); var rs = con.querySync('select * from rdb$relations'); var rows = rs.fetchSync("all",true); con.disconnect(); res.write('['); rows.forEach(function(r){ res.write(JSON.stringify(r)+','); }); res.end(']'); }).listen(1337, "127.0.0.1"); console.log('Server running at http://127.0.0.1:1337/');

कुल हस्तांतरित: 199310000 बाइट्स
HTML स्थानांतरित: 198670000 बाइट्स
प्रति सेकंड अनुरोध: 52.47 [# / सेकंड] (मतलब)

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

 var cfg = require("../config").cfg; var fb = require('../../firebird'); var util = require('util'); var http = require('http'); http.createServer(function (req, res) { res.writeHead(200, {'Content-Type': 'text/plain'}); var con = fb.createConnection(); con.connect(cfg.db, cfg.user, cfg.password, cfg.role,function(){ con.query('select * from rdb$relations',function(err,rs){ res.write('['); rs.fetch("all",true,function(r){ res.write(JSON.stringify(r)+','); }, function(err){ con.disconnect(); res.end(']'); }); }); }); }).listen(1337, "127.0.0.1"); console.log('Server running at http://127.0.0.1:1337/');

कुल हस्तांतरित: 199310000 बाइट्स
HTML स्थानांतरित: 198670000 बाइट्स
प्रति सेकंड अनुरोध: 129.26 [# / सेकंड] (मतलब)

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

हालांकि, इस कोड में अभी भी उप-रूपी बिंदु हैं जिन्हें अनुकूलित किया जा सकता है। उदाहरण के लिए, यह है कि प्रत्येक क्लाइंट कनेक्शन एक नया डेटाबेस कनेक्शन बनाता है। एक चरम मामले के रूप में, आइए एकल कनेक्शन के साथ प्राप्त करने का प्रयास करें। प्रारंभ में तुल्यकालिक संस्करण के लिए:

 var cfg = require("../config").cfg; var fb = require('../../firebird'); var util = require('util'); var http = require('http'); var con = fb.createConnection(); con.connectSync(cfg.db, cfg.user, cfg.password, cfg.role); http.createServer(function (req, res) { res.writeHead(200, {'Content-Type': 'text/plain'}); if(!con.inTransaction) con.startTransactionSync(); var rs = con.querySync('select * from rdb$relations'); var rows = rs.fetchSync("all",true); res.write('['); rows.forEach(function(r){ res.write(JSON.stringify(r)+','); }); res.end(']'); con.commitSync(); }).listen(1337, "127.0.0.1"); console.log('Server running at http://127.0.0.1:1337/');

कुल हस्तांतरित: 199310000 बाइट्स
HTML स्थानांतरित: 198670000 बाइट्स
प्रति सेकंड अनुरोध: 159.55 [# / सेकंड] (मतलब)

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

अब एसिंक्रोनस को जोड़ने का प्रयास करें। निम्नलिखित कोड स्पष्ट रूप से इष्टतम नहीं है - एकल कनेक्शन और अतुल्यकालिक का उपयोग करके हमें समानांतर में अनुरोधों को निष्पादित करने की अनुमति नहीं देगा। हालाँकि, प्रयोग की शुद्धता के लिए ...

 var cfg = require("../config").cfg; var fb = require('../../firebird'); var util = require('util'); var http = require('http'); var con = fb.createConnection(); con.connectSync(cfg.db, cfg.user, cfg.password, cfg.role), busy = false, next = []; http.createServer(function (req, res) { res.writeHead(200, {'Content-Type': 'text/plain'}); function doReq(){ con.query('select * from rdb$relations',function(err,rs){ res.write('['); rs.fetch("all",true,function(r){ res.write(JSON.stringify(r)+','); }, function(err){ res.end(']'); con.commit(function(){ busy = false; var n = next.pop(); if(n) n(); }); }); }); } function process(){ busy = true; if(!con.inTransaction) con.startTransaction(doReq); else doReq(); } if(busy) next.push(function(){ process(); }); else process(); }).listen(1337, "127.0.0.1"); console.log('Server running at http://127.0.0.1:1337/');

कुल हस्तांतरित: 199310000 बाइट्स
HTML स्थानांतरित: 198670000 बाइट्स
प्रति सेकंड अनुरोध: 129.85 [# / सेकंड] (मतलब)

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

 var cfg = require("../config").cfg; var fb = require('../../firebird'); var util = require('util'); var events = require('events'); var http = require('http'); function ConnectionPool() { events.EventEmitter.call(this); this.conns = []; this.busy = []; this.MaxConns = 5; this.newConn = function(){ var c = fb.createConnection(); c.connectSync(cfg.db, cfg.user, cfg.password, cfg.role); this.conns.push(c); }; this.get = function(cb) { var self = this; var c = this.conns.pop(); if(c) { this.busy.push(c); cb(c); } else if((this.busy.length) >= this.MaxConns){ this.once('release',function(){ self.get(cb); }); } else { this.newConn(); this.get(cb); } }; this.release = function(con){ for(var i=0;i<this.busy.length;i++) { if(this.busy[i] == con){ this.conns.push(this.busy[i]); this.busy.splice(i,1); var self = this; process.nextTick(function(){ self.emit('release'); }); return; } } }; } util.inherits(ConnectionPool, events.EventEmitter); var pool = new ConnectionPool(); pool.setMaxListeners(2000); function exec(con,res){ con.query('select * from rdb$relations',function(err,rs){ res.write('['); rs.fetch("all",true,function(r){ res.write(JSON.stringify(r)+','); },function(err){ res.end(']'); con.commit(function(){ pool.release(con); }); }); }); }; http.createServer(function (req, res) { res.writeHead(200, {'Content-Type': 'text/plain'}); pool.get(function(con){ if(!con.inTransaction) con.startTransaction(function(err){ if(!err) exec(con,res); }); else exec(con,res); }); }).listen(1337, "127.0.0.1"); console.log('Server running at http://127.0.0.1:1337/');

कुल हस्तांतरित: 199310000 बाइट्स
HTML स्थानांतरित: 198670000 बाइट्स
प्रति सेकंड अनुरोध: 187.82 [# / सेकंड] (मतलब)

बहुत कोड था, लेकिन प्रदर्शन में लाभ स्पष्ट है। इसके अलावा, कनेक्शन पूलिंग कोड को पुन: उपयोग के लिए एक अलग मॉड्यूल में ले जाया जा सकता है, और डेटाबेस ऑपरेशन कोड सरल और कॉम्पैक्ट रहेगा।

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

 var cfg = require("../config").cfg; var fb = require('../../firebird'); var util = require('util'); var events = require('events'); var http = require('http'); function StatementPool() { events.EventEmitter.call(this); this.conns = []; this.busy = []; this.MaxConns = 5; this.newConn = function(){ var c ={ conn: fb.createConnection() }; c.conn.connectSync(cfg.db, cfg.user, cfg.password, cfg.role); c.stmt = c.conn.prepareSync('select * from rdb$relations'); this.conns.push(c); }; this.get = function(cb) { var self = this; var c = this.conns.pop(); if(c) { this.busy.push(c); cb(c); } else if((this.busy.length) >=this.MaxConns){ this.once('release',function(){ self.get(cb); }); } else { this.newConn(); this.get(cb); } }; this.release = function(con){ for(var i=0;i<this.busy.length;i++) { if(this.busy[i] == con){ this.conns.push(this.busy[i]); this.busy.splice(i,1); var self = this; process.nextTick(function(){ self.emit('release'); }); return; } } }; } util.inherits(StatementPool, events.EventEmitter); var pool = new StatementPool(); pool.setMaxListeners(2000); http.createServer(function (req, res) { res.writeHead(200, {'Content-Type': 'text/plain'}); pool.get(function(con){ var exec = function(){ con.stmt.exec(); con.stmt.once('result',function(err){ res.write('['); con.stmt.fetch("all",true,function(r){ res.write(JSON.stringify(r)+','); }, function(err){ res.end(']'); con.conn.commit(function(){ pool.release(con); }); }); }); }; if(!con.conn.inTransaction) con.conn.startTransaction(function(err){ if(!err) exec(); }); else exec(); }); }).listen(1337, "127.0.0.1"); console.log('Server running at http://127.0.0.1:1337/');

कुल हस्तांतरित: 199310000 बाइट्स
HTML स्थानांतरित: 198670000 बाइट्स
प्रति सेकंड अनुरोध: 214.37 [# / सेकंड] (मतलब)

बड़ी मात्रा में कोड के बावजूद, यह विकल्प प्रति सेकंड 210 से अधिक अनुरोध देता है।

एक ही समय में कई कनेक्शनों का उपयोग करते हुए, तैयार किए गए अनुरोध और अतुल्यकालिक कॉल पूरी तरह से तुल्यकालिक संस्करण की तुलना में कम से कम 4 गुना लाभ देते हैं। हालाँकि, यह आंकड़ा केवल मेरे परीक्षण वातावरण के लिए सही है। आपको यह भी समझने की आवश्यकता है कि अकेले NodeJS में अतुल्यकालिक डेटाबेस सर्वर के प्रदर्शन में वृद्धि नहीं करता है, यह केवल इसे पूर्ण रूप से लोड करने में मदद करता है। इस मामले में, 256 एमबी मेमोरी और 1 प्रोसेसर कोर को डेटाबेस सर्वर को आवंटित किया गया था - यह मैं सामान्य रूप से छोटे आरपीएस में समझाता हूं। हालाँकि, मेमोरी लोड 3% से अधिक नहीं था। इसके अलावा, अतुल्यकालिक दृष्टिकोण अन्य प्रश्नों के समानांतर प्रसंस्करण की अनुमति देता है जो डेटाबेस प्रश्नों से संबंधित नहीं हैं। इन परीक्षणों में ऐसे कोई अनुरोध नहीं थे। RPS की संख्या में सबसे प्रभावशाली कारक क्वेरी नमूना का आकार था। इसलिए, नमूना को 10 रिकॉर्ड (परिणामी JSON में लगभग 1kb) तक सीमित करने और डेटाबेस सर्वर को 4 प्रोसेसर कोर आवंटित करने के दौरान, हम लगभग 1000 आरपीएस प्राप्त करने में कामयाब रहे, लेकिन इस मामले में सिंक्रोनस संस्करण लगभग 200 आरपीएस का उत्पादन किया। यह विचार करने योग्य है कि अतुल्यकालिक विकल्प, प्रति सेकंड 1000 डेटाबेस प्रश्नों को निष्पादित करना, एक साथ HTML को टेम्पलेट्स के अनुसार ड्राइंग करने में सक्षम है, जबकि सिंक्रोनस एक नहीं करता है।
सभी परीक्षण स्क्रिप्ट NodeJS के लिए फायरबर्ड एक्सेस मॉड्यूल का हिस्सा हैं
और गीथूब पर उपलब्ध है।

उदाहरण के रूप में फायरबर्ड का उपयोग करके बनाम बनाम सिंक

More articles: