[java] मैं जावा में माइक्रोसॉन्ड परिशुद्धता के साथ समय कैसे माप सकता हूं?


5 Answers

यह बिल्कुल स्पष्ट नहीं है कि आप बेंचमार्किंग कर रहे हैं, लेकिन आम तौर पर किसी भी परीक्षण में इतने कम समय लगते हैं कि 50 एमएस से कम सटीकता प्रासंगिक है, जो अन्य गड़बड़ी के लिए बहुत प्रवण होगी।

मैं आम तौर पर कम से कम 10 सेकंड के लिए बेंचमार्क चलाने की कोशिश करता हूं। इस समय मैं जिस फ्रेमवर्क को लिख रहा हूं, वह अनुमान लगाएगा कि कितने पुनरावृत्तियों को चलाने के लिए ताकि इसमें 30 सेकंड लग जाए। इसका मतलब है कि आपको मूल रूप से अलग-अलग परिणाम नहीं मिलेगा क्योंकि कुछ अन्य प्रक्रिया ने कुछ मिलीसेकंड के लिए सीपीयू चुरा लिया था।

लंबे समय तक चलने से फाइनर-ग्रेनेड सटीकता को मापने की कोशिश करने से लगभग हमेशा बेहतर दृष्टिकोण होता है।

Question

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

असल में, मेरे पास यह कोड है, उदाहरण के लिए, जावा लिंक की गई सूची में 10 मिलियन से 10 लाख प्रविष्टियां होती हैं। समस्या यह है कि मैं परिशुद्धता के अधिकार को माप नहीं सकता; कभी-कभी छोटी सूची में सब कुछ डालने में कम समय लगता है।

यहां एक उदाहरण दिया गया है:

class test
{
    public static void main(String args[])
    {
        for(int k=1000000; k<=10000000; k+=1000000)
        {
            System.out.println(k);
            LinkedList<Integer> aux = new LinkedList<Integer>();
            //need something here to see the start time
            for(int i=0; i<k; i++)
                aux.addFirst(10000);
            //need something here to see the end time
            //print here the difference between both times
        }
    }
}

मैंने कई बार ऐसा किया - एक बाहरी लूप प्रत्येक के लिए 20 बार कर रहा था - लेकिन नतीजा अच्छा नहीं है। कभी-कभी 10 मिलियन से अधिक 10 मिलियन सम्मिलन करने में कम समय लगता है, क्योंकि मुझे अब जो भी उपयोग हो रहा है, उसके साथ सही मापा समय नहीं मिल रहा है (System.nanoTime ())

संपादित करें 2: हां, मैं सूर्य जेवीएम का उपयोग कर रहा हूं।

संपादित करें 3: मैंने कोड में कुछ गलत किया होगा, मैं देखता हूं कि यह बदल रहा है जो मैं चाहता हूं।

संपादित करें 4: मेरी गलती, ऐसा लगता है System.nanoTime () काम करता है। ओह।




हमारे हालिया प्रोफाइलिंग के लिए, मैंने पाया कि ThreadMXBean.getCurrentThreadCpuTime () और विकल्प -XX: + UseLinuxPosixThreadCPUClocks ने हमें जो चाहिए वह किया।

अधिक जानकारी के लिए http://bugs.java.com/view_bug.do?bug_id=6888526 देखें




जावा.टाइम का उपयोग करना

एफवाईआई, जावा 9 और बाद में Clock का एक नया कार्यान्वयन है जो वर्तमान क्षण को नैनोसेकंद रिज़ॉल्यूशन तक कैप्चर कर सकता है।

Instant क्लास UTC में टाइमलाइन पर nanoseconds संकल्प के साथ एक पल का प्रतिनिधित्व करता है (दशमलव अंश के नौ (9) अंकों तक)।

वर्तमान क्षण को पकड़ने के लिए Instant.now पर कॉल करें।

  • जावा 9 और बाद में, आपको उस वर्तमान पल के लिए nanoseconds तक एक रिज़ॉल्यूशन मिलता है।
  • जावा 8 में, वर्तमान पल केवल milliseconds रिज़ॉल्यूशन तक कैप्चर किया जाता है (आप वास्तव में नैनोसेकंड के साथ मान रख सकते हैं, लेकिन केवल वर्तमान पल को मिलीसेकंड में कैप्चर कर सकते हैं)।

    तत्काल तत्काल = त्वरित .now ();

Duration वर्ग के साथ समयरेखा के साथ unattached समय की एक अवधि का प्रतिनिधित्व करें। सेकंड और नैनोसेकंड के मामले में समय की मात्रा रखती है।

Duration d = Duration.between( instantThen , Instant.now() );

स्पष्ट होने के लिए, प्रश्न में पूछा गया microseconds रेज़ोल्यूशन मिलीसेकंड और नैनोसेकंड की ग्रैन्युलरिटीज के बीच है। दशमलव अंश में स्थानों की संख्या: मिलिस 3 (0.123) है, माइक्रो 6 (0.123456) है, नैनो 9 (0.123456789) है।

चेतावनी

जावा आपके कंप्यूटर की हार्डवेयर घड़ी पर निर्भर करता है। जैसा कि अन्य ने चेतावनी दी थी, वह हार्डवेयर लगभग निश्चित रूप से कम सटीकता और नैनोसेकंड की तुलना में बहुत कम संकल्प के साथ समय पर कब्जा करेगा।

इस तरह की बढ़िया ग्रॅन्युलरिटी पर बेंचमार्किंग मुद्दों से भरा हुआ है और आम तौर पर सलाह नहीं दी जाती है

और समयपूर्व अनुकूलन से सावधान रहें।

जेईपी 230 में जावा प्लेटफ़ॉर्म में माइक्रो-बेंचमार्किंग सुविधा जोड़ने का एक प्रस्ताव है : माइक्रोबाइंचमार्क सूटजावा माइक्रोबेंमार्क हार्नेस (जेएमएच) के आधार पर।

जावा के बारे में

java.time फ्रेमवर्क जावा 8 और बाद में बनाया गया है। ये कक्षाएं परेशानी पुरानी legacy दिनांक-समय कक्षाओं जैसे java.util.Date , Calendar , और SimpleDateFormat

Joda-Time प्रोजेक्ट, अब रखरखाव मोड में , java.time कक्षाओं में माइग्रेशन की सलाह देता है।

अधिक जानने के लिए, ओरेकल ट्यूटोरियल देखें। और कई उदाहरणों और स्पष्टीकरणों के लिए स्टैक ओवरफ़्लो खोजें। विशिष्टता जेएसआर 310 है

जावा.टाइम कक्षाएं कहां प्राप्त करें?

  • जावा एसई 8 और एसई 9 और बाद में
    • निर्मित।
    • एक बंडल कार्यान्वयन के साथ मानक जावा एपीआई का हिस्सा।
    • जावा 9 कुछ मामूली विशेषताओं और फिक्सेस जोड़ता है।
  • जावा एसई 6 और एसई 7
    • जावाटाइम की अधिकांश कार्यक्षमता को ThreeTen-Backport में जावा 6 और 7 में बैक-पोर्ट किया गया है।
  • Android
    • ThreeTenABP प्रोजेक्ट विशेष रूप से एंड्रॉइड के लिए थ्रीटेन-बैकपोर्ट (ऊपर उल्लिखित) को अनुकूलित करता है।
    • देखें थ्रीटेबैप का उपयोग कैसे करें ...।

ThreeTen-Extra प्रोजेक्ट अतिरिक्त कक्षाओं के साथ जावा.टाइम बढ़ाता है। यह परियोजना java.time के संभावित भविष्य के जोड़ों के लिए एक सिद्ध भूमि है। आपको यहां कुछ उपयोगी कक्षाएं मिल सकती हैं जैसे Interval , YearWeek , YearQuarter , more




वह अजीब है। System.nanoTime () काम करना चाहिए। क्या आप सूर्य जेवीएम का उपयोग कर रहे हैं?

क्या आप अपने ऑपरेशन को 1000 बार दोहरा सकते हैं और 1000 से समय को विभाजित कर सकते हैं यह जानने के लिए कि आपको क्या जानना है?




ऐसा बेंचमार्क जो कम समय-अंतराल पर निर्भर करता है, आपको अविश्वसनीय परिणाम देता है। आई / ओ, स्वैपिंग, प्रोसेस स्विच, कैश, कचरा कलेक्शन इत्यादि जैसे बाहरी कारकों के कारण आपको हमेशा अलग-अलग परिणाम मिलेंगे। इसके अतिरिक्त जेवीएम आपकी कॉल को अनुकूलित करता है, इसलिए संभव है कि पहली मापी गई चीजें बाद में कॉल की तुलना में धीमी गति से चल रही हों। आपके द्वारा निष्पादित आदेशों को अनुकूलित करने के लिए JVM अधिक से अधिक प्रारंभ होता है।

इसके अतिरिक्त System.nanoTime () जैसी विधि अंतर्निहित प्रणाली के टाइमर पर निर्भर है। वे (और सबसे अधिक संभावना) में उस सटीकता में मापने के लिए ग्रैन्युलरिटी नहीं हो सकती है। System.nanoTime() उद्धृत करने के लिए:

यह विधि नैनोसेकंद परिशुद्धता प्रदान करती है, लेकिन जरूरी नहीं कि नैनोसेकंद सटीकता। कितनी बार मूल्य बदलते हैं इस बारे में कोई गारंटी नहीं दी जाती है।

वास्तव में उच्च परिशुद्धता के साथ मापने के लिए आपको गारंटीकृत सटीकता के साथ बाहरी समय हार्डवेयर तक पहुंचने की आवश्यकता है।

अपने बेंचमार्क को और अधिक स्थिर बनाने के लिए आपको इसे एक से अधिक बार निष्पादित करने और केवल मिलीसेकंड की तुलना में बड़े समय-अंतराल को मापने की आवश्यकता है।




यह मामला हो सकता है कि अंतर्निहित ओएस नैनोसेकंद परिशुद्धता वाले टाइमर प्रदान नहीं करता है।

एक पुरानी पोस्ट भी है।




Related



Tags

java java   time