गतिमान प्रतिबिंब बद्दल अयशस्वी लेख

मी लगेच लेखाच्या शीर्षकाचे स्पष्टीकरण देईन. मूळ योजना एक साधे पण वास्तववादी उदाहरण वापरून परावर्तनाचा वापर वाढविण्याबाबत चांगला, विश्वासार्ह सल्ला देण्याची होती, परंतु बेंचमार्किंग दरम्यान असे दिसून आले की प्रतिबिंब मला वाटले तितके हळू नाही, LINQ माझ्या दुःस्वप्नांपेक्षा हळू आहे. पण शेवटी असे निष्पन्न झाले की मी देखील मोजमापात चूक केली आहे... या जीवनकथेचे तपशील कटाखाली आणि टिप्पण्यांमध्ये आहेत. उदाहरण अगदी सामान्य आहे आणि तत्त्वानुसार एंटरप्राइझमध्ये केले जाते तसे अंमलात आणले गेले आहे, माझ्या मते, जीवनाचे प्रात्यक्षिक हे खूपच मनोरंजक ठरले: लेखाच्या मुख्य विषयाच्या गतीवर होणारा परिणाम लक्षात येण्यासारखा नव्हता. बाह्य तर्कामुळे: Moq, Autofac, EF Core आणि इतर "बँडिंग्ज".

मी या लेखाच्या छापाखाली काम करण्यास सुरुवात केली: प्रतिबिंब मंद का आहे

जसे तुम्ही बघू शकता, लेखकाने रिफ्लेक्शन टाईप पद्धतींना थेट कॉल करण्याऐवजी संकलित प्रतिनिधी वापरण्याचा सल्ला दिला आहे जेणेकरुन ऍप्लिकेशनचा वेग वाढवण्याचा एक चांगला मार्ग आहे. अर्थातच, IL उत्सर्जन आहे, परंतु मी ते टाळू इच्छितो, कारण हे कार्य करण्यासाठी सर्वात श्रम-केंद्रित मार्ग आहे, जे त्रुटींनी भरलेले आहे.

परावर्तनाच्या गतीबद्दल माझे नेहमीच असेच मत आहे हे लक्षात घेता, लेखकाच्या निष्कर्षांवर प्रश्नचिन्ह उपस्थित करण्याचा माझा विशेष हेतू नव्हता.

मला अनेकदा एंटरप्राइझमध्ये प्रतिबिंबाचा भोळा वापर आढळतो. प्रकार घेतला आहे. मालमत्तेची माहिती घेतली जाते. SetValue पद्धत म्हणतात आणि प्रत्येकजण आनंदित होतो. लक्ष्य क्षेत्रात मूल्य आले आहे, प्रत्येकजण आनंदी आहे. अतिशय हुशार लोक - वरिष्ठ आणि टीम लीड्स - त्यांचे विस्तार ऑब्जेक्टवर लिहितात, अशा निष्कलंक अंमलबजावणीच्या आधारे एका प्रकारच्या "सार्वत्रिक" मॅपर्सवर आधारित. सार सामान्यतः हे आहे: आम्ही सर्व फील्ड घेतो, सर्व गुणधर्म घेतो, त्यावर पुनरावृत्ती करतो: जर प्रकार सदस्यांची नावे जुळत असतील तर आम्ही सेटव्हॅल्यू कार्यान्वित करतो. वेळोवेळी आम्ही चुकांमुळे अपवाद पकडतो जेथे आम्हाला एका प्रकारात काही मालमत्ता आढळली नाही, परंतु येथे देखील एक मार्ग आहे जो कार्यप्रदर्शन सुधारतो. प्रयत्न करा / पकडा.

मी पाहिले आहे की लोक त्यांच्या आधी आलेल्या मशीन्स कसे कार्य करतात याबद्दल संपूर्ण माहितीने सशस्त्र न होता पार्सर आणि मॅपर्स पुन्हा शोधतात. मी पाहिले आहे की लोक रणनीतींच्या मागे, इंटरफेसच्या मागे, इंजेक्शन्सच्या मागे त्यांची साधी अंमलबजावणी लपवतात, जणू काही हे नंतरच्या बाकनालियाला माफ करेल. अशा जाणिवेने मी नाक वर केले. खरं तर, मी वास्तविक कार्यप्रदर्शन लीक मोजले नाही आणि, शक्य असल्यास, मी त्यावर हात मिळवू शकलो तर मी अंमलबजावणी अधिक "इष्टतम" मध्ये बदलली. म्हणून, खाली चर्चा केलेल्या पहिल्या मोजमापांनी मला गंभीरपणे गोंधळात टाकले.

मला वाटते की तुमच्यापैकी अनेकांनी, रिक्टर किंवा इतर विचारवंतांचे वाचन करून, एक पूर्णपणे न्याय्य विधान आढळले आहे की कोडमध्ये प्रतिबिंब ही एक घटना आहे ज्याचा अनुप्रयोगाच्या कार्यक्षमतेवर अत्यंत नकारात्मक प्रभाव पडतो.

कॉलिंग रिफ्लेक्शन CLR ला त्यांना आवश्यक असलेला एक शोधण्यासाठी, त्यांचा मेटाडेटा काढण्यासाठी, त्यांचे विश्लेषण करण्यासाठी असेंब्लीमधून जाण्यास भाग पाडते. या व्यतिरिक्त, सीक्वेन्स ट्रॅव्हर्स करताना प्रतिबिंब मोठ्या प्रमाणात मेमरीचे वाटप करते. आम्ही मेमरी वापरत आहोत, सीएलआर जीसी उघडते आणि फ्रिज सुरू होते. माझ्यावर विश्वास ठेवा, हे लक्षणीय हळू असावे. आधुनिक उत्पादन सर्व्हर किंवा क्लाउड मशीनवरील मेमरी मोठ्या प्रमाणात उच्च प्रक्रिया विलंब टाळत नाही. खरं तर, जितकी जास्त मेमरी, GC कसे कार्य करते हे लक्षात येण्याची शक्यता जास्त असते. प्रतिबिंब, सिद्धांततः, त्याच्यासाठी एक अतिरिक्त लाल चिंधी आहे.

तथापि, आम्ही सर्व IoC कंटेनर आणि तारीख मॅपर्स वापरतो, ज्याचे ऑपरेटिंग तत्त्व देखील प्रतिबिंबांवर आधारित आहे, परंतु त्यांच्या कार्यक्षमतेबद्दल सहसा कोणतेही प्रश्न नसतात. नाही, नाही कारण बाह्य मर्यादित संदर्भ मॉडेल्समधून अवलंबनांचा परिचय आणि अमूर्तता इतकी आवश्यक आहे की आम्हाला कोणत्याही परिस्थितीत कामगिरीचा त्याग करावा लागेल. सर्व काही सोपे आहे - याचा खरोखर कार्यप्रदर्शनावर फारसा परिणाम होत नाही.

वस्तुस्थिती अशी आहे की प्रतिबिंब तंत्रज्ञानावर आधारित सर्वात सामान्य फ्रेमवर्क त्याच्यासह अधिक चांगल्या प्रकारे कार्य करण्यासाठी सर्व प्रकारच्या युक्त्या वापरतात. सहसा हे कॅशे असते. सामान्यतः हे अभिव्यक्ती आणि अभिव्यक्ती ट्री वरून संकलित केलेले प्रतिनिधी असतात. तोच ऑटोमॅपर एक स्पर्धात्मक शब्दकोश राखतो जो फंक्शन्ससह प्रकारांशी जुळतो जे प्रतिबिंब कॉल न करता एकमेकांमध्ये रूपांतरित करू शकतात.

हे कसे साध्य होते? मूलत:, हे प्लॅटफॉर्म स्वतः JIT कोड व्युत्पन्न करण्यासाठी वापरत असलेल्या तर्कापेक्षा वेगळे नाही. जेव्हा एखादी पद्धत प्रथमच कॉल केली जाते, तेव्हा ती संकलित केली जाते (आणि, होय, ही प्रक्रिया जलद नाही); त्यानंतरच्या कॉलवर, नियंत्रण आधीच संकलित केलेल्या पद्धतीवर हस्तांतरित केले जाते आणि कोणतेही महत्त्वपूर्ण कार्यप्रदर्शन कमी होणार नाही.

आमच्या बाबतीत, तुम्ही JIT संकलन देखील वापरू शकता आणि नंतर संकलित वर्तन त्याच्या AOT समकक्षांप्रमाणेच कार्यक्षमतेसह वापरू शकता. या प्रकरणात अभिव्यक्ती आमच्या मदतीला येतील.

प्रश्नातील तत्त्व थोडक्यात खालीलप्रमाणे तयार केले जाऊ शकते:
संकलित फंक्शन असलेले प्रतिनिधी म्हणून तुम्ही परावर्तनाचा अंतिम निकाल कॅशे केला पाहिजे. तुमच्या प्रकारातील, कार्यकर्त्याच्या फील्डमधील सर्व आवश्यक वस्तूंच्या माहितीसह कॅशे करणे देखील अर्थपूर्ण आहे, जे ऑब्जेक्ट्सच्या बाहेर संग्रहित आहेत.

यात तर्क आहे. कॉमन सेन्स आपल्याला सांगते की जर एखादी गोष्ट संकलित आणि कॅश करता येत असेल तर ती केली पाहिजे.

पुढे पाहताना, असे म्हटले पाहिजे की प्रतिबिंबांसह कार्य करण्याच्या कॅशेचे त्याचे फायदे आहेत, जरी आपण अभिव्यक्ती संकलित करण्याची प्रस्तावित पद्धत वापरली नाही तरीही. खरं तर, मी वर उल्लेख केलेल्या लेखाच्या लेखकाच्या शोधनिबंधांची पुनरावृत्ती करत आहे.

आता कोडबद्दल. चला एक उदाहरण पाहू जे माझ्या अलीकडील वेदनांवर आधारित आहे ज्याचा मला गंभीर क्रेडिट संस्थेच्या गंभीर उत्पादनात सामना करावा लागला. कोणीही अंदाज लावू नये म्हणून सर्व संस्था काल्पनिक आहेत.

काही सार आहे. संपर्क असू द्या. प्रमाणित शरीरासह अक्षरे आहेत, ज्यावरून पार्सर आणि हायड्रेटर समान संपर्क तयार करतात. एक पत्र आले, आम्ही ते वाचले, ते की-व्हॅल्यू जोड्यांमध्ये पार्स केले, एक संपर्क तयार केला आणि डेटाबेसमध्ये सेव्ह केला.

ते प्राथमिक आहे. समजा संपर्कात पूर्ण नाव, वय आणि संपर्क फोन हे गुणधर्म आहेत. हा डेटा पत्राद्वारे प्रसारित केला जातो. अक्षराच्या मुख्य भागामध्ये जोड्यांमध्ये अस्तित्व गुणधर्म मॅप करण्यासाठी नवीन की जोडण्यासाठी सक्षम होण्यासाठी व्यवसायाला समर्थन देखील हवे आहे. जर एखाद्याने टेम्पलेटमध्ये टायपिंग केली असेल किंवा रिलीझ होण्यापूर्वी नवीन फॉरमॅटशी जुळवून घेत, नवीन भागीदाराकडून मॅपिंग तातडीने सुरू करणे आवश्यक आहे. मग आम्ही स्वस्त डेटाफिक्स म्हणून नवीन मॅपिंग सहसंबंध जोडू शकतो. म्हणजे जीवनाचे उदाहरण.

आम्ही अंमलबजावणी करतो, चाचण्या तयार करतो. कार्य करते.

मी कोड प्रदान करणार नाही: बरेच स्त्रोत आहेत आणि ते लेखाच्या शेवटी लिंकद्वारे GitHub वर उपलब्ध आहेत. तुम्ही त्यांना लोड करू शकता, त्यांना ओळखण्यापलीकडे छळू शकता आणि त्यांचे मोजमाप करू शकता, कारण त्याचा तुमच्या बाबतीत परिणाम होईल. मी फक्त दोन टेम्प्लेट पद्धतींचा कोड देईन जे हायड्रेटरला वेगळे करतात, जे जलद असायला हवे होते, हायड्रेटरपासून, जे स्लो असायला हवे होते.

लॉजिक खालीलप्रमाणे आहे: टेम्प्लेट पद्धत मूलभूत पार्सर लॉजिकद्वारे व्युत्पन्न केलेल्या जोड्या प्राप्त करते. LINQ लेयर हा हायड्रेटरचा पार्सर आणि मूलभूत तर्क आहे, जो डेटाबेस संदर्भासाठी विनंती करतो आणि पार्सरमधील जोड्यांसह कीची तुलना करतो (या कार्यांसाठी तुलना करण्यासाठी LINQ शिवाय कोड आहे). पुढे, जोड्या मुख्य हायड्रेशन पद्धतीकडे पाठवल्या जातात आणि जोड्यांची मूल्ये घटकाच्या संबंधित गुणधर्मांवर सेट केली जातात.

“फास्ट” (बेंचमार्कमध्ये उपसर्ग फास्ट):

 protected override Contact GetContact(PropertyToValueCorrelation[] correlations)
        {
            var contact = new Contact();
            foreach (var setterMapItem in _proprtySettersMap)
            {
                var correlation = correlations.FirstOrDefault(x => x.PropertyName == setterMapItem.Key);
                setterMapItem.Value(contact, correlation?.Value);
            }
            return contact;
        }

जसे आपण पाहू शकतो, सेटर गुणधर्मांसह एक स्थिर संग्रह वापरला जातो - संकलित लॅम्बडास ज्याला सेटर घटक म्हणतात. खालील कोडद्वारे तयार केले:

        static FastContactHydrator()
        {
            var type = typeof(Contact);
            foreach (var property in type.GetProperties())
            {
                _proprtySettersMap[property.Name] = GetSetterAction(property);
            }
        }

        private static Action<Contact, string> GetSetterAction(PropertyInfo property)
        {
            var setterInfo = property.GetSetMethod();
            var paramValueOriginal = Expression.Parameter(property.PropertyType, "value");
            var paramEntity = Expression.Parameter(typeof(Contact), "entity");
            var setterExp = Expression.Call(paramEntity, setterInfo, paramValueOriginal).Reduce();
            
            var lambda = (Expression<Action<Contact, string>>)Expression.Lambda(setterExp, paramEntity, paramValueOriginal);

            return lambda.Compile();
        }

सर्वसाधारणपणे हे स्पष्ट आहे. आम्ही गुणधर्म पार करतो, त्यांच्यासाठी प्रतिनिधी तयार करतो जे सेटर कॉल करतात आणि त्यांना जतन करतात. मग गरज असेल तेव्हा फोन करतो.

“स्लो” (बेंचमार्कमध्ये प्रिफिक्स स्लो):

        protected override Contact GetContact(PropertyToValueCorrelation[] correlations)
        {
            var contact = new Contact();
            foreach (var property in _properties)
            {
                var correlation = correlations.FirstOrDefault(x => x.PropertyName == property.Name);
                if (correlation?.Value == null)
                    continue;

                property.SetValue(contact, correlation.Value);
            }
            return contact;
        }

येथे आम्ही लगेच गुणधर्म बायपास करतो आणि सेटव्हॅल्यूला थेट कॉल करतो.

स्पष्टतेसाठी आणि संदर्भ म्हणून, मी एक साधी पद्धत लागू केली आहे जी त्यांच्या सहसंबंध जोड्यांची मूल्ये थेट घटक फील्डमध्ये लिहिते. उपसर्ग - मॅन्युअल.

आता बेंचमार्कडॉटनेट घेऊ आणि कामगिरी तपासू. आणि अचानक... (स्पॉयलर - हा योग्य निकाल नाही, तपशील खाली दिला आहे)

आम्ही येथे काय पाहतो? ज्या पद्धती विजयीपणे वेगवान उपसर्ग धारण करतात त्या स्लो उपसर्ग असलेल्या पद्धतींपेक्षा जवळजवळ सर्व पासांमध्ये हळू असतात. हे वाटप आणि कामाची गती या दोन्ही बाबतीत खरे आहे. दुसरीकडे, जेथे शक्य असेल तेथे LINQ पद्धती वापरून मॅपिंगची सुंदर आणि मोहक अंमलबजावणी, उलटपक्षी, उत्पादकता मोठ्या प्रमाणात कमी करते. फरक ऑर्डरचा आहे. पासच्या वेगवेगळ्या संख्येने कल बदलत नाही. फरक फक्त स्केलमध्ये आहे. LINQ सह ते 4 - 200 पट कमी आहे, अंदाजे त्याच प्रमाणात जास्त कचरा आहे.

अद्यतनित

माझा माझ्या डोळ्यांवर विश्वास बसला नाही, पण सर्वात महत्त्वाचे म्हणजे आमच्या सहकाऱ्याचा माझ्या डोळ्यांवर किंवा माझ्या कोडवर विश्वास बसला नाही - दिमित्री तिखोनोव 0x1000000. माझे समाधान दोनदा तपासल्यानंतर, त्याने उत्कृष्टपणे शोधून काढले आणि एक त्रुटी निदर्शनास आणून दिली जी अंमलबजावणीतील अनेक बदलांमुळे मी चुकलो, सुरुवातीपासून अंतिम. Moq सेटअपमध्ये आढळलेल्या बगचे निराकरण केल्यानंतर, सर्व परिणाम जागेवर पडले. पुनर्परीक्षण परिणामांनुसार, मुख्य प्रवृत्ती बदलत नाही - LINQ अद्याप प्रतिबिंबापेक्षा कार्यप्रदर्शनावर अधिक परिणाम करते. तथापि, हे छान आहे की अभिव्यक्ती संकलित करण्याचे कार्य व्यर्थ ठरले नाही आणि परिणाम वाटप आणि अंमलबजावणी वेळेत दोन्ही दृश्यमान आहे. पहिले प्रक्षेपण, जेव्हा स्टॅटिक फील्ड सुरू केले जातात, ते नैसर्गिकरित्या "जलद" पद्धतीसाठी हळू होते, परंतु नंतर परिस्थिती बदलते.

पुन्हा चाचणीचा निकाल येथे आहे:

निष्कर्ष: एंटरप्राइझमध्ये प्रतिबिंब वापरताना, युक्त्या वापरण्याची विशेष आवश्यकता नाही - LINQ उत्पादकता अधिक खाईल. तथापि, ऑप्टिमायझेशन आवश्यक असलेल्या उच्च-लोड पद्धतींमध्ये, आपण इनिशिएलायझर्स आणि प्रतिनिधी कंपाइलर्सच्या रूपात प्रतिबिंब जतन करू शकता, जे नंतर "जलद" तर्क प्रदान करेल. अशा प्रकारे तुम्ही परावर्तनाची लवचिकता आणि अॅप्लिकेशनची गती दोन्ही राखू शकता.

बेंचमार्क कोड येथे उपलब्ध आहे. कोणीही माझे शब्द दोनदा तपासू शकतो:
HabraReflection Tests

PS: चाचण्यांमधील कोड IoC वापरतो आणि बेंचमार्कमध्ये तो स्पष्ट रचना वापरतो. वस्तुस्थिती अशी आहे की अंतिम अंमलबजावणीमध्ये मी कार्यप्रदर्शन प्रभावित करणारे आणि परिणाम गोंगाट करणारे सर्व घटक कापले.

PPS: वापरकर्त्याचे आभार दिमित्री टिखोनोव @0x1000000 Moq सेट करताना माझी त्रुटी शोधल्याबद्दल, ज्याने प्रथम मोजमाप प्रभावित केले. वाचकांपैकी कोणाकडे पुरेसे कर्म असेल तर कृपया लाईक करा. माणूस थांबला, माणूस वाचला, त्या माणसाने दोनदा तपासले आणि चूक निदर्शनास आणून दिली. मला वाटते की हे आदर आणि सहानुभूती पात्र आहे.

PPPS: शैली आणि डिझाइनच्या तळापर्यंत पोहोचलेल्या सूक्ष्म वाचकाचे आभार. मी एकरूपता आणि सोयीसाठी आहे. सादरीकरणातील मुत्सद्दीपणा खूप काही हवे आहे, परंतु मी टीका लक्षात घेतली. मी अस्त्र मागतो.

स्त्रोत: www.habr.com