V8 के बारे में एक कहानी, प्रतिक्रिया और प्रदर्शन में गिरावट। भाग 1

सामग्री, जिसके अनुवाद का पहला भाग आज हम प्रकाशित करते हैं, चर्चा करेंगे कि कैसे V8 जावास्क्रिप्ट इंजन स्मृति में विभिन्न JS मानों का प्रतिनिधित्व करने के सर्वोत्तम तरीकों का चयन करता है, और यह तथाकथित रूपों के साथ काम करने के बारे में V8 के आंतरिक तंत्र को कैसे प्रभावित करता है। वस्तुएं (आकार)। यह सब हमें हाल ही में प्रतिक्रिया प्रदर्शन के मुद्दे के सार को सुलझाने में मदद करेगा।

जावास्क्रिप्ट डेटा प्रकार

प्रत्येक JavaScript मान में आठ मौजूदा डेटा प्रकारों में से केवल एक हो सकता है: Number , String , Symbol , BigInt , Boolean , Undefined , Null और Object ।


जावास्क्रिप्ट डेटा प्रकार

typeof ऑपरेटर का उपयोग करके मूल्य का प्रकार निर्धारित किया जा सकता है, लेकिन एक महत्वपूर्ण अपवाद है:

 typeof 42; // 'number' typeof 'foo'; // 'string' typeof Symbol('bar'); // 'symbol' typeof 42n; // 'bigint' typeof true; // 'boolean' typeof undefined; // 'undefined' typeof null; // 'object' -   ,     typeof { x: 42 }; // 'object' 

जैसा कि आप देख सकते हैं, typeof null कमांड 'object' , न कि 'null' , इस तथ्य के बावजूद कि null का अपना प्रकार है - Null । इस typeof व्यवहार के कारण को समझने के लिए, हम इस तथ्य को ध्यान में रखते हैं कि सभी जावास्क्रिप्ट प्रकारों के सेट को दो वर्गों में विभाजित किया जा सकता है:

• ऑब्जेक्ट (यानी, Object टाइप करें)।
• आदिम मूल्य (अर्थात, कोई भी गैर-विशेषण मूल्य)।

इस ज्ञान के प्रकाश में, यह पता चला है कि null अर्थ है "कोई वस्तु नहीं", जबकि undefined अर्थ है "कोई मूल्य नहीं"।


आदिम मूल्य, वस्तुएं, अशक्त और अपरिभाषित

जावा की भावना में इन प्रतिबिंबों के बाद, ब्रेंडन ईच ने जावास्क्रिप्ट को डिजाइन किया ताकि typeof ऑपरेटर उन प्रकारों के मूल्यों के लिए 'object' लौटाए जो पिछले आंकड़े में दाईं ओर स्थित हैं। सभी वस्तु मूल्य और null यहाँ मिलते हैं। इसीलिए एक्सप्रेशन typeof null === 'object' सही है, हालाँकि लैंग्वेज स्पेसिफिकेशन में एक अलग टाइप Null है।


अभिव्यक्ति टाइपो v === 'ऑब्जेक्ट' सत्य है

मूल्यों का प्रतिनिधित्व

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

उदाहरण के लिए, जावास्क्रिप्ट में 42 का मान टाइप number ।

 typeof 42; // 'number' 

मेमोरी में 42 जैसे पूर्णांकों का प्रतिनिधित्व करने के कई तरीके हैं:

ECMAScript मानक के अनुसार, संख्याएं 64-बिट फ्लोटिंग पॉइंट वैल्यूज़ हैं, जिन्हें डबल-प्रिसिजन फ़्लोटिंग-पॉइंट नंबर (फ़्लोट 64) के रूप में जाना जाता है। हालांकि, इसका मतलब यह नहीं है कि जावास्क्रिप्ट इंजन हमेशा फ्लोट64 दृश्य में नंबर स्टोर करते हैं। यह बहुत, बहुत अक्षम होगा! इंजन संख्याओं के अन्य आंतरिक अभ्यावेदन का उपयोग कर सकते हैं - जब तक कि मूल्यों का व्यवहार वास्तव में मेल खाता है कि फ्लोट64 नंबर कैसे व्यवहार करते हैं।

वास्तविक जेएस अनुप्रयोगों में अधिकांश संख्या, जैसा कि यह निकला, वैध ECMAScript सरणी इंडेक्स हैं । वह है - 0 से 2 ³² -2 की सीमा में पूर्णांक।

 array[0]; //      . array[42]; array[2**32-2]; //      . 

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

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

 for (let i = 0; i < 1000; ++i) {  //  } for (let i = 0.1; i < 1000.1; ++i) {  //  } 

गणितीय ऑपरेटरों का उपयोग करके गणना पर भी यही लागू होता है।

उदाहरण के लिए, अगले कोड के टुकड़े से शेष भाग लेने के ऑपरेटर का प्रदर्शन इस बात पर निर्भर करता है कि गणना में कौन सी संख्याएँ शामिल हैं।

 const remainder = value % divisor; //  -  `value`  `divisor`   , //    . 

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

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

 //  Float64   53-  . //         . 2**53 === 2**53+1; // true // Float64   ,   -1 * 0   -0,  //           . -1*0 === -0; // true // Float64   Infinity,   , //     . 1/0 === Infinity; // true -1/0 === -Infinity; // true // Float64    NaN. 0/0 === NaN; 

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

हस्ताक्षरित पूर्णांक के 31-बिट प्रतिनिधित्व की सीमा के भीतर आने वाले छोटे पूर्णांक के मामले में, V8 एक विशेष प्रतिनिधित्व का उपयोग करता है जिसे Smi कहा जाता है। वह सब कुछ जो एक Smi मूल्य नहीं है, एक HeapObject मान के रूप में HeapObject जाता है, जो स्मृति में कुछ इकाई का पता है। संख्याओं के लिए, जो HeapObject श्रेणी में नहीं आते हैं, हमारे पास एक विशेष प्रकार का HeapObject - तथाकथित HeapNumber ।

 -Infinity // HeapNumber -(2**30)-1 // HeapNumber  -(2**30) // Smi       -42 // Smi        -0 // HeapNumber         0 // Smi       4.2 // HeapNumber        42 // Smi   2**30-1 // Smi     2**30 // HeapNumber  Infinity // HeapNumber       NaN // HeapNumber 

जैसा कि आप पिछले उदाहरण से देख सकते हैं, कुछ JS संख्याओं को Smi रूप में HeapNumber , और कुछ HeapNumber रूप में। V8 इंजन को Smi नंबर को प्रोसेस करने के मामले में ऑप्टिमाइज़ किया गया है। तथ्य यह है कि वास्तविक जेएस कार्यक्रमों में छोटे पूर्णांक बहुत आम हैं। Smi मानों के साथ काम करते समय, व्यक्तिगत संस्थाओं के लिए मेमोरी आवंटित करना आवश्यक नहीं है। इसके अलावा, उनका उपयोग आपको पूर्णांक के साथ त्वरित संचालन करने की अनुमति देता है।

एसएमआई, हीपन्नंबर और म्यूटेबलहेननंबर की तुलना

आइए बात करते हैं कि इन तंत्रों की आंतरिक संरचना कैसी दिखती है। मान लें कि हमारे पास निम्नलिखित वस्तु है:

 const o = {  x: 42, // Smi  y: 4.2, // HeapNumber }; 

ऑब्जेक्ट x की संपत्ति का मान 42 Smi रूप में एन्कोडेड है। इसका मतलब है कि इसे ऑब्जेक्ट के अंदर ही स्टोर किया जा सकता है। दूसरी तरफ मूल्य 4.2 को स्टोर करने के लिए, आपको एक अलग इकाई बनाने की आवश्यकता होगी। ऑब्जेक्ट में इस इकाई का लिंक होगा।


विभिन्न मूल्यों का भंडारण

मान लें कि हम जावास्क्रिप्ट कोड के निम्नलिखित टुकड़े को निष्पादित कर रहे हैं:

 ox += 10; // ox   52 oy += 1; // oy   5.2 

इस स्थिति में, इसके भंडारण स्थान पर संपत्ति x का मूल्य अद्यतन किया जा सकता है। तथ्य यह है कि x का नया मान 52 है, और यह संख्या Smi की सीमा में आती है।


प्रॉपर्टी x का नया मान संग्रहीत किया जाता है जहां पिछला मान संग्रहीत किया गया था।

हालाँकि, y , 5.2 का नया मान, Smi की श्रेणी में फिट नहीं है, और यह, इसके अलावा, y - 4.2 के पिछले मूल्य से भिन्न है। परिणामस्वरूप, V8 को नई HeapNumber इकाई के लिए मेमोरी आवंटित HeapNumber और इसे पहले ही ऑब्जेक्ट से संदर्भित करना होगा।


नई इकाई HeapNumber नए y मान को संग्रहीत करने के लिए

HeapNumber इकाइयां अपरिवर्तनीय हैं। यह आपको कुछ अनुकूलन लागू करने की अनुमति देता है। मान लें कि हम ऑब्जेक्ट x की संपत्ति को संपत्ति y x मूल्य पर सेट करना चाहते हैं:

 ox = oy; // ox   5.2 

इस ऑपरेशन को निष्पादित करते समय, हम बस एक ही HeapNumber यूनिट को संदर्भित कर सकते हैं, और समान मूल्य को संग्रहीत करने के लिए अतिरिक्त मेमोरी आवंटित नहीं कर सकते हैं।

HeapNuber संस्थाओं की प्रतिरक्षा का एक नुकसान यह है कि Smi रेंज के बाहर के मूल्यों के साथ लगातार अद्यतन धीमा है। यह निम्नलिखित उदाहरण में दिखाया गया है:

 //   `HeapNumber`. const o = { x: 0.1 }; for (let i = 0; i < 5; ++i) {  //    `HeapNumber`.  ox += 1; } 

पहली पंक्ति को संसाधित करते समय, HeapNumber का एक उदाहरण बनाया जाता है, जिसका प्रारंभिक मूल्य 0.1 है। चक्र के शरीर में, यह मान 1.1, 2.1, 3.1, 4.1 और अंत में 5.1 में बदल जाता है। नतीजतन, इस कोड को निष्पादित करने की प्रक्रिया में, HeapNumber 6 उदाहरण HeapNumber , जिनमें से पांच लूप के पूरा होने के बाद कचरा संग्रह संचालन के अधीन होंगे।


HeapNumber इकाइयाँ

इस समस्या से बचने के लिए, V8 में ऑप्टिमाइज़ेशन है, जो संख्यात्मक क्षेत्रों को अपडेट करने के लिए एक तंत्र है, जिनके मान उसी श्रेणी में Smi श्रेणी में फिट नहीं होते हैं जहां वे पहले से ही संग्रहीत हैं। यदि कोई संख्यात्मक फ़ील्ड उन मानों को संग्रहीत करता है जिनके लिए Smi निकाय संग्रहण के लिए उपयुक्त नहीं है, तो V8, ऑब्जेक्ट के रूप में, इस फ़ील्ड को Double रूप में चिह्नित करता है और MutableHeapNumber इकाई के लिए मेमोरी आवंटित करता है, जो फ़्लोट64 प्रारूप में दर्शाए गए वास्तविक मूल्य को संग्रहीत करता है।


MutableHeapNumber संस्थाओं का उपयोग करना

परिणामस्वरूप, फ़ील्ड मान में परिवर्तन होने के बाद, V8 को नई HeapNumber इकाई के लिए मेमोरी आवंटित करने की आवश्यकता नहीं है। इसके बजाय, बस एक मौजूदा MutableHeapNumber इकाई में नया मान लिखें।


MutableHeapNumber के लिए एक नया मान लिखना

हालांकि, इस दृष्टिकोण में इसकी कमियां हैं। अर्थात्, चूंकि MutableHeapNumber के मान बदल सकते हैं, यह सुनिश्चित करना महत्वपूर्ण है कि सिस्टम इस तरह से MutableHeapNumber कि ये मान भाषा विनिर्देश में दिए गए अनुसार व्यवहार करते हैं।


MutableHeapNumber का नुकसान

उदाहरण के लिए, यदि आप कुछ अन्य चर y ox मान निर्दिष्ट करते हैं, तो आपको यह सुनिश्चित करने की आवश्यकता है कि ox में बाद के परिवर्तन के साथ y का मूल्य नहीं बदलता है। यह जावास्क्रिप्ट विनिर्देश का उल्लंघन होगा! परिणामस्वरूप, ox तक पहुँचने के लिए, संख्या को सामान्य रूप से HeapNumber मान पर HeapNumber किया जाना चाहिए, इससे पहले कि उसे y असाइन किया जाए।

फ्लोटिंग-पॉइंट नंबरों के मामले में, V8 अपने आंतरिक तंत्र का उपयोग करके उपरोक्त पैकिंग ऑपरेशन करता है। लेकिन छोटे पूर्णांकों के मामले में, MutableHeapNumber का उपयोग करना समय की बर्बादी होगी क्योंकि ऐसी संख्याओं का प्रतिनिधित्व करने के लिए Smi एक अधिक कुशल तरीका है।

 const object = { x: 1 }; // ""  `x`    object.x += 1; //   `x`   

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


उन पूर्णांकों के साथ काम करें जिनके मूल्य एसआईआई की सीमा में आते हैं

जारी रखने के लिए ...

प्रिय पाठकों! क्या आपने जेएस इंजन सुविधाओं के कारण जावास्क्रिप्ट प्रदर्शन के मुद्दों का सामना किया है?