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


Answers

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

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

लम्बे समय तक चलने के लिए लगभग हमेशा बेहतर सटीकता के साथ मापने की कोशिश करने की तुलना में एक बेहतर तरीका है।

Question

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

मूल रूप से, मुझे यह कोड है, उदाहरण के लिए, जावा लिंक की गई सूची में 1 करोड़ 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 बार यह एक बाहरी लूप था - लेकिन इसका परिणाम अच्छा नहीं है। कभी-कभी 1 मिलियन से 10 मिलियन सम्मिलन करने के लिए कम समय लगता है, क्योंकि मुझे अब जो उपयोग हो रहा है (सिस्टम। नैनो टाइम) के साथ सही समय नहीं मिल रहा है

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

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

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




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

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




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

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




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

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

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

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

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




Java.time का उपयोग करना

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

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

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

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

    झटपट तत्काल = त्वरित।

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

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

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

चेतावनी

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

इस तरह के ठीक ग्रैन्युलैरिटी पर बेंचमार्किंग मुद्दों से भरा है और उचित रूप से उचित नहीं है

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

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

जावा के बारे में। समय

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

जोडा-टाइम प्रोजेक्ट, अब रखरखाव मोड में , जावा के समय की कक्षाओं के लिए प्रवासन की सलाह देते हैं।

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

जावा को कब प्राप्त करें कक्षाएं?

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




हमारी हाल की रूपरेखा के लिए, मुझे पता चला है कि थ्रेडमक्सबीन.टाट्राउंटरट्रेड सीपीयूम () और विकल्प -XX: + यूज़ लिनक्सपीसिक्सट्रेडक्यूकॉक्ल्स ने हमारे लिए क्या किया था

अधिक विवरणों के लिए http://bugs.java.com/view_bug.do?bug_id=6888526 देखें




Links