👩🏼‍🤝‍👩🏻 🌈 🚛 नोड.जेएस को तेज करना: देशी मॉड्यूल और सीयूडीए 👩🏿‍🌾 🕗 👵🏼

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

इस लेख में, मैं इस बारे में बात करूंगा कि आप नोड के काम को कैसे तेज करने की कोशिश कर सकते हैं। जेएस (जो अपने आप में काफी तेज माना जाता है)। हम C ++ का उपयोग करके लिखे गए मूल एक्सटेंशन के बारे में बात करेंगे।

विस्तार के बारे में संक्षेप में

तो, आपके पास Node.JS पर एक वेब सर्वर है और आपको संसाधन-गहन एल्गोरिदम के साथ एक कार्य मिला है। कार्य को पूरा करने के लिए, C ++ में एक मॉड्यूल लिखने का निर्णय लिया गया। अब हमें यह पता लगाने की जरूरत है कि यह क्या है - एक देशी विस्तार।

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

क्या विचार करें?

फ़ंक्शन लें:

यह फ़ंक्शन निम्न सतह को परिभाषित करता है:

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

var func = function(x,y){ return Math.sin(x*y)/(1+Math.sqrt(x*x+y*y))+2; } function integrateJS(x0,xN,y0,yN,iterations){ var result=0; var time = new Date().getTime(); for (var i = 0; i < iterations; i++){ for (var j = 0; j < iterations; j++){ //    var x = x0 + (xN - x0) / iterations * i; var y = y0 + (yN - y0) / iterations * j; var value = func(x, y); //   //        result+=value*(xN-x0)*(yN-y0)/(iterations*iterations); } } console.log("JS result = "+result); console.log("JS time = "+(new Date().getTime() - time)); }

एक्सटेंशन लिखने की तैयारी कर रहा है

अब हम C ++ में सभी समान कार्य करते हैं। व्यक्तिगत रूप से, मैंने Microsoft Visual Studio 2010 का उपयोग किया। सबसे पहले, हमें Node.JS स्रोतों को डाउनलोड करना होगा। हम आधिकारिक वेबसाइट पर जाते हैं और स्रोत के नवीनतम संस्करण को खींचते हैं। स्रोत फ़ोल्डर में फ़ाइल vcbuild.bat है, जो विज़ुअल स्टूडियो और कॉन्फ़िगरेशन के लिए आवश्यक प्रोजेक्ट बनाता है। काम करने के लिए बैच फ़ाइल के लिए, पायथन की आवश्यकता है। यदि आपके पास नहीं है, तो हम इसे ऑफ साइट से सेट करते हैं। हम पर्यावरण चर चर में अजगर को पथ लिखते हैं (अजगर 2.7 के लिए यह C: \ththon27 होगा; C: \ Python27 \ Scripts)। बैच फ़ाइल चलाएँ, आवश्यक फ़ाइलें प्राप्त करें। अगला, हमारे मॉड्यूल के लिए एक .cpp फ़ाइल बनाएँ। अगला, json प्रारूप में हमारे मॉड्यूल का विवरण लिखें:

  { "targets": [ { "target_name": "funcIntegrate", "sources": [ "funcIntegrate.cpp" ] } ] }

हम इसे बाइंडिंग के रूप में सहेजते हैं। जिप और उस पर उपयोगिता सेट करें, जिसे हम npm का उपयोग करके इंस्टॉल करते हैं। यह उपयोगिता विंडोज के लिए एक ठीक से कॉन्फ़िगर स्टूडियो फ़ाइल vcxproj या लिनक्स के लिए मेकफाइल बनाती है। इसके अलावा, एक कॉमरेड द्वारा एक बैच फ़ाइल बनाई गई थी, जिससे स्टूडियो के लिए एक प्रोजेक्ट स्थापित करना और बनाना भी आसान हो गया था। आप इसे उनसे ले सकते हैं, साथ ही हेलोवर्ल्ड मॉड्यूल का एक उदाहरण। फ़ाइल संपादित करें, बैच फ़ाइल चलाएँ - समाप्त .node मॉड्यूल प्राप्त करें। आप मैन्युअल रूप से एक विजुअल स्टूडियो प्रोजेक्ट बना सकते हैं और मैन्युअल रूप से सभी सेटिंग्स को ड्राइव कर सकते हैं - लिबास और हेडर नोड के रास्ते। js, कॉन्फ़िगरेशन प्रकार को .dll, टारगेट एक्सटेंशन - .node पर सेट करें।

मूल विस्तार

सब कुछ कॉन्फ़िगर किया गया है, हम कोड लिखना शुरू करते हैं।

.Cpp फ़ाइल में, हमें ObjectWrap से विरासत में मिला एक वर्ग घोषित करना चाहिए। इस वर्ग की सभी विधियाँ स्थिर होनी चाहिए।
एक आरंभीकरण फ़ंक्शन होना चाहिए जिसे हम NODE_MODULE मैक्रो में चलाते हैं। NODE_SET_PROTOTYPE_METHOD मैक्रो का उपयोग करते हुए, आरंभीकरण फ़ंक्शन में, हम उन विधियों को निर्दिष्ट करते हैं जो Node.JS से उपलब्ध होंगी। हम प्रेषित मापदंडों को प्राप्त कर सकते हैं, उनकी संख्या और प्रकारों की जांच कर सकते हैं और यदि आवश्यक हो, तो अपवादों को फेंक सकते हैं। एक विस्तार बनाने के लिए सभी आवश्यक चीजों का विस्तृत विवरण, आप यहां पा सकते हैं

कोड

 #include <node.h> //  #include <v8.h> #include <math.h> using namespace node; using namespace v8; //,       js float func(float x, float y){ return sin(x*y)/(1+sqrt(x*x+y*y))+2; } char* funcCPU(float x0, float xn, float y0, float yn, int iterations){ double x,y,value,result; result=0; for (int i = 0; i < iterations; i++){ for (int j = 0; j < iterations; j++){ x = x0 + (xn - x0) / iterations * i; y = y0 + (yn - y0) / iterations * j; value = func(x, y); result+=value*(xn-x0)*(yn-y0)/(iterations*iterations); } } char *c = new char[20]; sprintf(c,"%f",result); return c; } //  ,    ObjectWrap class funcIntegrate: ObjectWrap{ public: //.        static static void Init(Handle<Object> target){ HandleScope scope; Local<FunctionTemplate> t = FunctionTemplate::New(New); Persistent<FunctionTemplate> s_ct = Persistent<FunctionTemplate>::New(t); s_ct->InstanceTemplate()->SetInternalFieldCount(1); //    javascript s_ct->SetClassName(String::NewSymbol("NativeIntegrator")); //,   javasript NODE_SET_PROTOTYPE_METHOD(s_ct, "integrateNative", integrateNative); target->Set(String::NewSymbol("NativeIntegrator"),s_ct->GetFunction()); } funcIntegrate(){ } ~funcIntegrate(){ } //    Node.JS      new static Handle<Value> New(const Arguments& args){ HandleScope scope; funcIntegrate* hw = new funcIntegrate(); hw->Wrap(args.This()); return args.This(); } // ,   javasript static Handle<Value> integrateNative(const Arguments& args){ HandleScope scope; funcIntegrate* hw = ObjectWrap::Unwrap<funcIntegrate>(args.This()); //   args,    double   funcCPU. //     Local<String> result = String::New(funcCPU(args[0]->NumberValue(),args[1]->NumberValue(),args[2]->NumberValue(),args[3]->NumberValue(),args[4]->NumberValue())); return scope.Close(result); } }; extern "C" { static void init (Handle<Object> target){ funcIntegrate::Init(target); } NODE_MODULE(funcIntegrate, init); };

इस कोड को संकलित करने के बाद, हमें एक .node फ़ाइल (एक अलग एक्सटेंशन के साथ एक नियमित DLL) मिलती है, जिसे हमारी Node.JS परियोजना से जोड़ा जा सकता है। फ़ाइल में NativeIntegrator js ऑब्जेक्ट का एक प्रोटोटाइप है, जिसमें एक एकीकृत विधि है। परिणामी मॉड्यूल कनेक्ट करें:

 var funcIntegrateNative = require("./build/funcIntegrate.node"); nativeIntegrator = new funcIntegrateNative.NativeIntegrator(); function integrateNative(x0,xN,y0,yN,iterations){ var time = new Date().getTime(); result=nativeIntegrator.integrateNative(x0,xN,y0,yN,iterations); console.log("Native result = "+result); console.log("Native time = "+(new Date().getTime() - time)); }

इस कोड को Node.JS पर पहले से पूरी की गई परियोजना में जोड़ें, फ़ंक्शन को कॉल करें, तुलना करें:

 function main(){ integrateJS(-4,4,-4,4,1024); integrateNative(-4,4,-4,4,1024); } main();

हमें इसका परिणाम मिलता है:
जेएस परिणाम = 127.99999736028109
जेएस समय = 127
मूल परिणाम = 127.999997
मूल समय = १०३

अंतर न्यूनतम है। आइए अक्षों के साथ पुनरावृत्तियों की संख्या 8 गुना बढ़ाएं। हमें निम्न परिणाम मिलते हैं:

जेएस परिणाम = 127.99999995875444
जेएस समय = 6952
मूल परिणाम = 128.000000
देशी समय = 6658

निष्कर्ष

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

नोड.जेएस वास्तव में बहुत तेज है। यदि आप निम्न-स्तरीय अनुकूलन के साथ उच्च-गुणवत्ता C ++ कोड लिखना नहीं जानते हैं, तो प्रदर्शन को गति देने के लिए मूल एक्सटेंशन लिखने का प्रयास करने का कोई मतलब नहीं है। आपको केवल अनावश्यक समस्याएं आएंगी।
मूल एक्सटेंशन का उपयोग करें जहां आपको वास्तव में इसकी आवश्यकता है - उदाहरण के लिए, जहां आपको कुछ सिस्टम एपीआई तक पहुंच की आवश्यकता होती है जो कि Node.JS में नहीं है।

हमें और गहरे जाने की जरूरत है

लेकिन चलो हमारे कोड को गति देने का प्रयास करें? चूंकि हमारे पास मूल एक्सटेंशन से लेकर कुछ भी, यानी वीडियो कार्ड तक पहुंच है। हम CUDA का उपयोग करते हैं!

ऐसा करने के लिए, हमें CUDA SDK की आवश्यकता होती है, जिसे Nvidia वेबसाइट पर पाया जा सकता है। मैं यहां स्थापना और कॉन्फ़िगरेशन के बारे में बात नहीं करूंगा, इसके लिए कई मैनुअल हैं। एसडीके को स्थापित करने के बाद, हमें प्रोजेक्ट में कुछ बदलाव करने की आवश्यकता है - स्रोत को .cpp से .cu में बदल दें। हम निर्माण सेटिंग्स में CUDA समर्थन जोड़ते हैं। CUDA संकलक सेटिंग्स में आवश्यक निर्भरता जोड़ें। परिवर्तन और परिवर्धन पर टिप्पणियों के साथ यहां नया एक्सटेंशन कोड दिया गया है:

कोड

 #include <node.h> #include <v8.h> #include <math.h> #include <cuda_runtime.h> //  CUDA using namespace node; using namespace v8; //  __device__ __host__ //      CPU,    GPU. __device__ __host__ float func(float x, float y){ return sin(x*y)/(1+sqrt(x*x+y*y))+2; } //__global__ -   CPU,   GPU __global__ void funcGPU(float x0, float xn, float y0, float yn, float *result){ float x = x0 + (xn - x0) / gridDim.x * blockIdx.x; float y = y0 + (yn - y0) / blockDim.x * threadIdx.x ; float value = func(x, y); result[gridDim.x * threadIdx.x + blockIdx.x] = value*(xn-x0)*(yn-y0)/(gridDim.x*blockDim.x); } char* funcCPU(float x0, float xn, float y0, float yn, int iterations){ double x,y,value,result; result=0; for (int i = 0; i < iterations; i++){ for (int j = 0; j < iterations; j++){ x = x0 + (xn - x0) / iterations * i; y = y0 + (yn - y0) / iterations * j; value = func(x, y); result+=value*(xn-x0)*(yn-y0)/(iterations*iterations); } } char *c = new char[20]; sprintf(c,"%f",result); return c; } class funcIntegrate: ObjectWrap{ private: static dim3 gridDim; //    static dim3 blockDim; static float *result; static float *resultDev; public: static void Init(Handle<Object> target){ HandleScope scope; Local<FunctionTemplate> t = FunctionTemplate::New(New); Persistent<FunctionTemplate> s_ct = Persistent<FunctionTemplate>::New(t); s_ct->InstanceTemplate()->SetInternalFieldCount(1); s_ct->SetClassName(String::NewSymbol("NativeIntegrator")); NODE_SET_PROTOTYPE_METHOD(s_ct, "integrateNative", integrate); //     GPU,  Node.JS NODE_SET_PROTOTYPE_METHOD(s_ct, "integrateCuda", integrateCuda); target->Set(String::NewSymbol("NativeIntegrator"),s_ct->GetFunction()); //   CUDA gridDim.x = 256; blockDim.x = 256; result = new float[gridDim.x * blockDim.x]; cudaMalloc((void**) &resultDev, gridDim.x * blockDim.x * sizeof(float)); } funcIntegrate(){ } ~funcIntegrate(){ cudaFree(resultDev); } //    static char* cudaIntegrate(float x0, float xn, float y0, float yn, int iterations){ cudaEvent_t start, stop; cudaEventCreate(&start); cudaEventCreate(&stop); //    CPU  GPU //           GPU - //      bCount,   //  GPU   int bCount = iterations/gridDim.x; float bSizeX=(xn-x0)/bCount; float bSizeY=(yn-y0)/bCount; double res=0; for (int i = 0; i < bCount; i++){ for (int j = 0; j < bCount; j++){ cudaEventRecord(start, 0); //  //   GPU funcGPU<<<gridDim, blockDim>>>(x0+bSizeX*i, x0+bSizeX*(i+1), y0+bSizeY*j, y0+bSizeY*(j+1), resultDev); cudaEventRecord(stop, 0); cudaEventSynchronize(stop); //  //    GPU    cudaMemcpy(result, resultDev, gridDim.x * blockDim.x * sizeof(float), cudaMemcpyDeviceToHost); //   for (int k=0; k<gridDim.x * blockDim.x; k++) res+=result[k]; } } cudaEventDestroy(start); cudaEventDestroy(stop); char *c = new char[200]; sprintf(c,"%f", res); return c; } static Handle<Value> New(const Arguments& args){ HandleScope scope; funcIntegrate* hw = new funcIntegrate(); hw->Wrap(args.This()); return args.This(); } static Handle<Value> integrate(const Arguments& args){ HandleScope scope; funcIntegrate* hw = ObjectWrap::Unwrap<funcIntegrate>(args.This()); Local<String> result = String::New(funcCPU(args[0]->NumberValue(),args[1]->NumberValue(),args[2]->NumberValue(),args[3]->NumberValue(),args[4]->NumberValue())); return scope.Close(result); } //     CUDA static Handle<Value> integrateCuda(const Arguments& args){ HandleScope scope; funcIntegrate* hw = ObjectWrap::Unwrap<funcIntegrate>(args.This()); Local<String> result = String::New(cudaIntegrate(args[0]->NumberValue() ,args[1]->NumberValue(),args[2]->NumberValue(),args[3]->NumberValue(),args[4]->NumberValue())); return scope.Close(result); } }; extern "C" { static void init (Handle<Object> target){ funcIntegrate::Init(target); } NODE_MODULE(funcIntegrate, init); }; dim3 funcIntegrate::blockDim; dim3 funcIntegrate::gridDim; float* funcIntegrate::result; float* funcIntegrate::resultDev;

आइए js में एक हैंडलर लिखें:

 function integrateCuda(x0,xN,y0,yN,iterations){ var time = new Date().getTime(); result=nativeIntegrator.integrateCuda(x0,xN,y0,yN,iterations); console.log("CUDA result = "+result); console.log("CUDA time = "+(new Date().getTime() - time)); }

निम्नलिखित डेटा पर परीक्षण चलाएं:

 function main(){ integrateJS(-4,4,-4,4,1024); integrateNative(-4,4,-4,4,1024); integrateCuda(-4,4,-4,4,1024); }

परिणाम प्राप्त करें:

जेएस परिणाम = 127.99999736028109
जेएस समय = ११ ९
मूल परिणाम = 127.999997
मूल समय = १२२
CUDA परिणाम = 127.999997
CUDA समय = 17

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

  integrateJS(-4,4,-4,4,1024*16); integrateNative(-4,4,-4,4,1024*16); integrateCuda(-4,4,-4,4,1024*16);

हमें इसका परिणाम मिलता है:
जेएस परिणाम = 127.99999998968899
जेएस समय = 25401
मूल परिणाम = 128.000000
देशी समय = 28405
CUDA परिणाम = 128.000000
कूडा समय = 3568

जैसा कि हम देखते हैं, अंतर बहुत बड़ा है। CUDA पर एक अनुकूलित एल्गोरिथ्म हमें परिमाण के एक आदेश से अधिक का प्रदर्शन अंतर देगा। (और इस परीक्षण पर C ++ कोड भी प्रदर्शन में Node.JS से पिछड़ गया)।

निष्कर्ष

हमारे द्वारा मानी जाने वाली स्थिति काफी विचित्र है। Node.JS के साथ एक वेब सर्वर पर संसाधन-गहन कंप्यूटिंग, जो एक मशीन पर स्थापित है जिसमें एक ग्राफिक्स कार्ड है जो CUDA प्रौद्योगिकी का समर्थन करता है। ऐसा अक्सर नहीं देखा जाता है। लेकिन अगर आपको कभी ऐसी किसी चीज का सामना करना पड़े - आप जानते हैं, ऐसी चीजें वास्तविक हैं। वास्तव में, आप किसी भी चीज को C ++ में Node.JS पर अपने सर्वर में लिख सकते हैं। वह है, कुछ भी।

देशी एक्सटेंशन बनाने के लिए उपयोगी लिंक

nodejs.org/api/addons.html
botsikas.blogspot.com/2011/12/building-native-modules-for-nodejs-06.html
www.cloudkick.com/blog/2010/aug/23/writing-nodejs-native-extensions

नोड.जेएस को तेज करना: देशी मॉड्यूल और सीयूडीए

विस्तार के बारे में संक्षेप में

क्या विचार करें?

एक्सटेंशन लिखने की तैयारी कर रहा है

मूल विस्तार

निष्कर्ष

हमें और गहरे जाने की जरूरत है

निष्कर्ष

More articles: