अंतर्निहित सॉफ्टवेयर अनुप्रयोग रनटाइम नियंत्रण

प्रकाशन C / C ++ / C # में लिखे गए अनुप्रयोगों के रनटाइम पर मीट्रिक जानकारी एकत्र करने और संचित करने के लिए अंतर्निहित उपकरणों का एक सॉफ्टवेयर कार्यान्वयन प्रस्तुत करता है।

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

दिए गए C ++ / C # स्रोत कोड उदाहरण वर्णित दृष्टिकोण के संभावित कार्यान्वयन को प्रदर्शित करते हैं।

परिचय

अपने विकासवादी विकास के प्रत्येक पुनरावृत्ति (उदाहरण के लिए, अगली रिलीज़ की रिलीज़) पर एक सॉफ़्टवेयर एप्लिकेशन के विकास में निम्नलिखित बुनियादी चरण शामिल हैं:

• कार्यक्षमता का विकास और परीक्षण;
• रैम के उपभोग किए गए संसाधनों का अनुकूलन;
• रनटाइम मैट्रिक्स का स्थिरीकरण।

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

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

यह भी ध्यान दिया जाना चाहिए कि इस वर्ग के सॉफ्टवेयर उत्पाद, एक नियम के रूप में, कक्षाओं और कार्यों के तरीकों के स्तर पर प्रोग्राम कोड के निष्पादन समय का एक मीट्रिक विश्लेषण करते हैं, कम (लेकिन समस्या के विश्लेषण के दृष्टिकोण से महत्वपूर्ण नहीं है) के स्तर की अनदेखी करते हुए: {...}, के लिए। जबकि, कब तक, अगर - और, कोशिश-पकड़ ब्लॉक, जिसके अंदर निष्पादन समय का कोई कम महत्वपूर्ण व्यय नहीं होता है।

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

रनटाइम डेटा को पुनः प्राप्त करने के तरीके

किसी भी सॉफ़्टवेयर एप्लिकेशन की कार्यक्षमता को एक अमूर्त मशीन के रूप में व्याख्या की जा सकती है जिसमें अद्वितीय राज्यों {सेंट} और उनके बीच {Tr} के परिमित सेट होते हैं।

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

निर्दिष्ट नियंत्रण बिंदुओं पर अनुप्रयोग निष्पादन समय पर डेटा का निष्कर्षण और संचय नीचे वर्णित नियंत्रण उपकरणों द्वारा हल किया गया मुख्य कार्य है।

प्रत्येक ब्रेकपॉइंट के लिए सोर्स कोड में घोषित करके
PROFILE_ENTRY C ++ मैक्रो, एप्लिकेशन निष्पादन के दौरान इसके अंशों की संख्या दर्ज की जाती है, साथ ही समय मीट्रिक - कुल समय राज्य में उस समय था जब चेकपॉइंट प्रोग्राम पदानुक्रम के अगले स्तर (एक ब्लॉक, क्लास विधि, फ़ंक्शन, आदि) से पारित हो जाता है। जैसा कि नीचे चित्र में दिखाया गया है।

नियंत्रण बिंदुओं का नियंत्रण (उनके समय मैट्रिक्स का प्रारंभिक पंजीकरण और गणना) 'टाइममैनर' ऑब्जेक्ट द्वारा किया जाता है, जो एक एकल उदाहरण में बनाया गया है। नियंत्रण बिंदु को पारित करने की प्रत्येक घटना को ऑब्जेक्ट 'टाइममैनर' द्वारा दर्ज किया जाता है , और पहले पारित होने के दौरान इसे 'रजिस्टरइन्स्ट्री' के रूप में वेधशालाओं द्वारा पंजीकृत किया जाता है।

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



नीचे स्रोत C ++ कोड है जो एप्लिकेशन के निष्पादन समय को नियंत्रित करने के लिए अंतर्निहित टूल को लागू करता है।

//     #include <vector> #include <map> #include <algorithm> #include <stdio.h> #include <time.h> typedef unsigned long LONGEST_INT; // ,    //     //     //  ( )   // ()   //    #define PROFILER_ENABLED // CREATE_PROFILER  timeManager , //     // 'main()' #ifdef PROFILER_ENABLED #define CREATE_PROFILER timeManager tManager; #else #define CREATE_PROFILER //   CREATE_PROFILER. #endif //INITIALIZE_PROFILER    timeManager  //       //   'main()' #ifdef PROFILER_ENABLED #define INITIALIZE_PROFILER bool timeManager::object = false;\ std::vector<registerEntry> timeManager::entries; #else #define INITIALIZE_PROFILER //   INITIALIZE_PROFILER. #endif //DELAY(_SECONDS)   '_SECONDS' . //    ,  //     //  #ifdef PROFILER_ENABLED #define DELAY(_SECONDS) {clock_t clk_wait=clock()+((double)_ARG)*CLOCKS_PER_SEC;\ while(clock()<clk_wait) {}} #else #define DELAY(_SECONDS) //    DELAY. #endif //     , //     UNIX  WINDOWS //      #ifdef PROFILER_ENABLED #define MERGE2(x,y) x##y #define MERGE1(_X,_Y) MERGE2(_X,_Y) #if WIN32 #define UNIQUENAME prefix,postfix) MERGE1(prefix,postfix) #else #define UNIQUENAME(prefix,postfix) MERGE2(prefix,postfix) #endif #define GEN_SRC(_ARG1,_ARG2) static int UNIQUENAME(ind,_ARG2)=-1;\ if(UNIQUENAME(ind,_ARG2)<0)\ UNIQUENAME(ind,_ARG2)=timeManager::add_entry(_ARG1);\ timeManager::incr_counter(UNIQUENAME(ind,_ARG2));\ timerObject UNIQUENAME(tm,_ARG2)(UNIQUENAME(ind,_ARG2)); //PROFILE_ENTRY      #ifdef PROFILER_ENABLED #if WIN32 #define PROFILE_ENTRY(_TITLE) GEN_SRC(_TITLE,__COUNTER__) #else #define PROFILE_ENTRY(_TITLE) GEN_SRC(_TITLE,__LINE__) #endif #else #define PROFILE_ENTRY(_TITLE) //    PROFILE_ENTRY. #endif //        //    //    ,   timeManager struct registerEntry { //     (  ) std::string entry_name; //     //     LONGEST_INT covers_counter; //      //     (ticks) LONGEST_INT elapsed_time; // registerEntry(const char * title):entry_name(title), covers_counter(0), elapsed_time(0) {} }; //     class timerObject { //   ,     int index; //    clock_t start_time; public: //       timerObject(int ind):index(ind),start_time(clock()) {} //    “ ”  //       //   ~timerObject(void) { timeManager::incr_timer(index,(LONGEST_INT)(clock()-start_time)); } }; //     class timeManager { private: //     static std::vector<registerEntry> entries; // ,     //    static bool object; public: //     //  ,    //     static int add_entry(const char * title) { entries.push_back(registerEntry(title)); return (((int)entries.size())-1); } //       //      static void incr_counter(int profile_entry_id) { entries[profile_entry_id].covers_counter++; } //  'value'     //      static void incr_timer(int profile_entry_id, LONGEST_INT value) { entries[profile_entry_id].elapsed_time += val; } //       //   static void report(void); //  timeManager(void) { if(!object) object = true; else { printf("\n<<>>:    'timeManager' .\n"); throw; } } //        //   virtual ~timeManager(void) {report();} }; //      bool cmp_entries(registerEntry & first, registerEntry & second) { if(first.entry_name.compare(second.entry_name)>0) return false; return true; } //      //    void timeManager::report(void) { const std::string bar(72,'*'); //        const char * REPORT_FILE = "C:\\tmProfile.txt"; FILE * fp = fopen(REPORT_FILE,"w"); if(!fp) { printf("\n<<>>:       (%s)",REPORT_FILE); return; } fprintf(fp,"\n#%s",bar.c_str()); fprintf(fp,"\n#\n#      "); fprintf(fp,"\n#\n#%s",bar.c_str()); fprintf(fp,"\n#\n# %-35s %-15s %-20s", " ",""," ()"); fprintf(fp,"\n# %-35s %-15s %-20s", "------------------","-------------","---------------\n#"); //         std::sort(entries.begin(),entries.end(),cmp_entries); for(unsigned jj = 0; jj< entries.size(); jj++) { fprintf(fp,"\n# %-35s %-16d", entries[jj].entry_name.c_str(), entries[jj].covers_counter); if(entries[jj].covers_counter == 0) fprintf(fp,"%-20d",0); else fprintf(fp,"%-20.0f", static_cast<double>(entries[jj].elapsed_time)/ static_cast<double>(CLOCKS_PER_SEC)); } if(entries.size() == 0) fprintf(fp,"\n# No covered profile entries found\n"); fprintf(fp,"\n#\n#%s\n",bar.c_str()); fclose(fp); } 

डेमो एप्लिकेशन की संरचना नीचे दी गई है, उदाहरण के रूप में अंतर्निहित रनटाइम कंट्रोल टूल के उपयोग को दर्शाते हुए, साथ ही प्राप्त परिणामों की एक तालिका (विवरण के लिए, परिशिष्ट 1 देखें। डेमो एप्लिकेशन का स्रोत कोड )।





अनुभाग परिशिष्ट 2. C # एप्लिकेशन के निष्पादन समय के लिए अंतर्निहित नियंत्रण उपकरणों का स्रोत कोड C # में अंतर्निहित नियंत्रणों के समान कार्यान्वयन को प्रस्तुत करता है।

इलेक्ट्रॉनिक उपकरणों के लिए एक कंप्यूटर एडेड डिजाइन प्रणाली - EREMEX द्वारा विकसित डेल्टा डिजाइन सॉफ्टवेयर सिस्टम के भाग के रूप में श्रमसाध्य निष्पादन दृष्टिकोण से तरीकों और प्रक्रियाओं को पूरा करते समय लेखक TimeWatcher.StartWatch () और TimeWatcher.StopWatch () के जोड़े का उपयोग करता है।

नीचे दिए गए उत्पाद की कार्यक्षमता में से एक के समय मैट्रिक्स पर एक संक्षिप्त रिपोर्ट का एक उदाहरण है।

संक्षिप्त निष्कर्ष

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

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

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

परिशिष्ट 1. डेमो आवेदन के लिए स्रोत कोड

 INITIALIZE_PROFILER int main(int argc, char * argv[]) { //create profile manager CREATE_PROFILER PROFILE_ENTRY("1 Main context") f11(); for(unsigned jj = 0;jj<4;jj++) f12(); f13 (); f14 (); f15 (); f16 (); f17(); return 0; } void f11(void)///////////////////////////////////////// { PROFILE_ENTRY ("2 f11()........................") for (unsigned jj = 0; jj<5; jj++) { PROFILE_ENTRY ("2 f11()::for(...){...} iterat-ing") DELAY(1) } //profile entry for repeating int nn(3); while(nn > 0) { PROFILE_ENTRY("2 f11()::while(...){...} iterat-ing") DELAY(1) nn--; } } void f12(void)///////////////////////////////////////// { PROFILE_ENTRY("3 f12()........................") goto ending; { PROFILE_ENTRY("3 f12()::ignored code part") DELAY(1) } ending: PROFILE_ENTRY("3 f12()::ending code part") DELAY(2) } void f13(void) ///////////////////////////////////////// { PROFILE_ENTRY("4 f13()........................") srand((unsigned) time(NULL)/2); for(unsigned jj = 0; jj < 200; jj++) { if(rand()%2 == 0) { PROFILE_ENTRY("4 f13()::even branch") DELAY(0.01) } else { PROFILE_ENTRY("4 f13()::od branch") DELAY(0.02) } } } void f14(void)///////////////////////////////////////// { static int depth = 10; { PROFILE_ENTRY("5 f14() recursion") depth--; DELAY(0.5) if(depth == 0) return; } f14(); } void f15(void)///////////////////////////////////////// { PROFILE_ENTRY("7 f15()........................") for(unsigned jj = 0; jj < 10; jj++) { demo_class obj; obj.method1(); obj.method2(); obj.method3(); } } void f16(void)///////////////////////////////////////// { PROFILE_ENTRY("8 f16()........................") try { for(int jj = 10; jj >= 0; jj--) { PROFILE_ENTRY("81 f16() try clause") DELAY(1) int rr = 200/jj; } } catch(...) { PROFILE_ENTRY("81 f16() catch clause") DELAY(2) return; } } void f17(void)///////////////////////////////////////// { PROFILE_ENTRY("9 f17()........................") f21(); f22(); f23(); f24(); f25(); } void f22(void)///////////////////////////////////////// { PROFILE_ENTRY("91 f22()........................") DELAY(1) f221(); f222(); f223(); } void f23(void) {PROFILE_ENTRY("91 f23()") DELAY(1) } void f24(void) {PROFILE_ENTRY("91 f24()") DELAY(1) } void f25(void) {PROFILE_ENTRY("91 f25()") DELAY(1) } void f221(void) {PROFILE_ENTRY("91 f221()") DELAY(3) } void f222(void) {PROFILE_ENTRY("91 f222()") DELAY(4) } void f223(void) {PROFILE_ENTRY("91 f223()") DELAY(5) } 

अनुपूरक 2. अंतर्निहित रनटाइम नियंत्रण सी # अनुप्रयोगों के स्रोत कोड

 /// <summary> ///             /// </summary> public class TimeWatcher { /// <summary> ///            /// </summary> internal class TimeEntry { //     public Stopwatch timeWatch; //       public long elapsedTime; //  public TimeEntry() { timeWatch = new Stopwatch(); elapsedTime = 0; } } //       //    private static bool enableTimeWatcher = false; //            private static Dictionary<string, TimeEntry> entryDictionary = new Dictionary<string, TimeEntry>(); //         public static void StartWatch(string postfix = "") { if (!enableTimeWatcher) return; string entryName = GetCurrentMethod(); if (postfix != "") { entryName += postfix; } //    ,      //         if (!entryDictionary.ContainsKey(entryName)) { entryDictionary.Add(entryName, new TimeEntry()); entryDictionary[entryName].timeWatch.Start(); } else { if (entryDictionary[entryName].timeWatch.IsRunning) { throw new System.InvalidOperationException(":    '" + entryName + "'  ."); } else entryDictionary[entryName].timeWatch.Restart(); } } //        public static void StopWatch(string postfix = "") { if (!enableTimeWatcher) return; string entryName = GetCurrentMethod(); if (postfix != "") { entryName += postfix; } //    ,      if (!entryDictionary.ContainsKey(entryName)) { throw new System.InvalidOperationException(":     -    '" + entryName + "'."); } if (!entryDictionary[entryName].timeWatch.IsRunning) { throw new System.InvalidOperationException ":        '" + entryName + "'."); } entryDictionary[entryName].timeWatch.Stop(); entryDictionary[entryName].elapsedTime += entryDictionary[entryName].timeWatch.ElapsedMilliseconds; } //        //     public static void TimeWatchReport() { const string bar = "============================================="; if (!enableTimeWatcher) return; Console.WriteLine(""); Console.WriteLine(bar); Console.WriteLine("     (): "); Console.WriteLine(""); int maxLen = 0; foreach (var timeEntry in entryDictionary) { if(timeEntry.Key.Length > maxLen) maxLen = timeEntry.Key.Length; } maxLen++; string strFormat = "{0," + maxLen + "} ... {1,-10}"; foreach (var timeEntry in entryDictionary) { Console.WriteLine(strFormat, timeEntry.Key, timeEntry.Value.elapsedTime); } Console.WriteLine(bar); Console.WriteLine(""); entryDictionary.Clear(); enableTimeWatcher = false; } //          //      /tmw    //   public static void InitTimeWatch() { if (Environment.GetCommandLineArgs().Any(v => v == "/tmw")) { if (entryDictionary.Count > 0) { TimeWatchReport(); } entryDictionary.Clear(); enableTimeWatcher = true; } } //        private static string GetCurrentMethod() { StackTrace st = new StackTrace(); StackFrame sf = st.GetFrame(2); return sf.GetMethod().Name; } }