मैं यह जानना चाहता हूं कि एक विशेष फ़ंक्शन कितने मिलीसेकंड का उपयोग करता है। तो मैंने उच्च और निम्न देखा, लेकिन रूबी में मिलीसेकंद परिशुद्धता के साथ समय निकालने का कोई तरीका नहीं मिला।रुबी में मिलीसेकंड में ऑपरेशन कैसे करें?
आप यह कैसे करते हैं? सबसे प्रोग्रामिंग भाषाओं में अपने जैसे
start = now.milliseconds
myfunction()
end = now.milliseconds
time = end - start
आप रूबी के Time कक्षा का उपयोग कर सकते हैं। उदाहरण के लिए:
t1 = Time.now
# processing...
t2 = Time.now
delta = t2 - t1 # in seconds
अब, delta एक float वस्तु है और आप के रूप में ठीक अनाज एक परिणाम के रूप वर्ग प्रदान करेगा मिल सकती है।
उपयोग Time.now.to_f
कुछ आप बेंचमार्क मॉड्यूल पर एक नज़र डालें मानक प्रदर्शन करने के लिए करना चाहिए।
def time
now = Time.now.to_f
yield
endd = Time.now.to_f
endd - now
end
नोट Time.now.to_f का उपयोग, जो to_i के विपरीत, सेकंड के लिए काट-छांट नहीं होगा: हालांकि, एक त्वरित और गंदी समय विधि के रूप में आप कुछ इस तरह उपयोग कर सकते हैं।
तुम भी में निर्मित Benchmark.measure फ़ंक्शन का उपयोग कर सकते हैं:
require "benchmark"
puts(Benchmark.measure { sleep 0.5 })
प्रिंटों:
0.000000 0.000000 0.000000 ( 0.501134)
मुझे एक निर्मित लाइब्रेरी का उपयोग करने का विचार पसंद है, लेकिन पहले तीन नंबर ('0.000000') क्या हैं? _ अद्यतन करें: _ इसे देखा [दस्तावेज़ों में] (http://ruby-doc.org/stdlib-1.9.3/libdoc/benchmark/rdoc/Benchmark.html) और यह उपयोगकर्ता CPU समय, सिस्टम CPU समय और योग है उन दोनों में से। – lyonsinbeta
हां। यदि आप 'Benchmark.bm' का उपयोग करते हैं तो उन्हें लेबल किया जाता है। यह देखने में उपयोगी होता है कि कभी-कभी समय कहाँ बिताया जाता है। यहां आप देख सकते हैं कि ब्लॉक सिर्फ निष्क्रिय है (0 कुल, 0.5 वास्तविक) –
या वहां एक 'बेंचमार्क.रेल्टटाइम' है जो एक समझने योग्य फ्लोट देता है :) –
absolute_time मणि एक ड्रॉप में बेंचमार्क के लिए प्रतिस्थापन है, लेकिन करने के लिए मूल निर्देश का उपयोग करता है कहीं अधिक सटीक हो।
या हिटिम्स मणि जिसमें पूर्ण_टाइम की तुलना में विंडोज़ पर उच्च ग्रॅन्युलरिटी हो सकती है ... – rogerdpack
Time.now.to_i का उपयोग दूसरे दिन 1 9 70/01/01 से पारित किया गया। यह जानने के बाद आप
date1 = Time.now.to_f
date2 = Time.now.to_f
diff = date2 - date1
कर सकते हैं। आप मिलीसेकेंड में यह चाहते हैं, बस कोड
diff = diff * 1000
'' '.to_i''' एक पूर्णांक देता है और मिलीसेकंड को छोटा कर देगा। यह काम करेगा अगर आपने इसे अभी '' '.to_f''' –
हाँ में बदल दिया है, जैसा कि रयान कहते हैं; डाउनवोट के लिए क्षमा चाहते हैं, लेकिन वास्तव में यह एक अपवित्र था और मुझे इसका सामना करने के लिए मजबूर होना पड़ा। मिलीसेकंड प्राप्त करने के लिए 1000 से सेकंड में _integer_ समय अंतर गुणा करना? चलो अब, एमएआरसी.आरएस, निश्चित रूप से आप बस हमें तंग कर रहे थे! :-) –
नहीं, बस मेरी पूरी कोशिश कर रहा है –
आप
date = Time.now.to_i
आप सेकंड में समय प्राप्त करने का उपयोग करते हैं करने के लिए जोड़ने के लिए, कि सही से दूर है, विशेष रूप से यदि आप समय कर रहे हैं कोड के छोटे भाग।
मेरे पास एक मणि है जो आपकी रूबी विधि (उदाहरण या कक्षा) - https://github.com/igorkasyanchuk/benchmark_methods प्रोफाइल कर सकता है।इस तरह
कोई और अधिक कोड:
t = Time.now
user.calculate_report
puts Time.now - t
अब आप कर सकते हैं:
benchmark :calculate_report # in class
और बस फोन अपने विधि
user.calculate_report
जो दीवार-घड़ी रिटर्न Time.now का उपयोग करना (समय) क्योंकि बेस-लाइनों में कुछ समस्याएं हैं जिनके परिणामस्वरूप अप्रत्याशित व्यवहार हो सकता है। यह इस तथ्य के कारण होता है कि संदर्भ समय पर स्थानीय समय समायोजित करने के लिए वॉलक्लॉक समय सम्मिलित लीप-सेकंड या time slewing जैसे परिवर्तनों के अधीन है।
यदि उदा। माप के दौरान डाला गया दूसरा छलांग, यह एक सेकंड से बंद हो जाएगा। इसी प्रकार, स्थानीय सिस्टम स्थितियों के आधार पर, आपको डेलाइट-सेविंग-टाइम्स, तेज या धीमी गति से चलने वाली घड़ियों, या घड़ी को समय पर वापस कूदना पड़ सकता है, जिसके परिणामस्वरूप नकारात्मक अवधि होती है, और कई अन्य समस्याएं होती हैं।
इस समस्या का समाधान घड़ी के एक अलग समय का उपयोग करना है: एक monotonic घड़ी। दीवार घड़ी की तुलना में इस प्रकार की घड़ी में अलग-अलग गुण होते हैं। यह monitonically वृद्धि करता है, यानी कभी वापस नहीं जाता है और निरंतर दर पर बढ़ता है। इसके साथ, यह दीवार घड़ी का प्रतिनिधित्व नहीं करता है (यानी जब आप अपनी दीवार पर घड़ी से पढ़ते हैं) लेकिन एक टाइमस्टैम्प जिसे आप अंतर के लिए बाद के टाइमस्टैम्प से तुलना कर सकते हैं।
t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
# => 63988.576809828
sleep 1.5 # do some work
t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
# => 63990.08359163
delta = t2 - t1
# => 1.5067818019961123
delta_in_milliseconds = delta * 1000
# => 1506.7818019961123
Process.clock_gettime विधि आंशिक सेकंड के साथ एक नाव के रूप में एक टाइमस्टैम्प रिटर्न:
रूबी में, आप इस तरह के एक टाइमस्टैम्प Process.clock_gettime(Process::CLOCK_MONOTONIC) तरह के साथ इस प्रकार का उपयोग कर सकते हैं। लौटाई गई वास्तविक संख्या में कोई परिभाषित अर्थ नहीं है (जिसे आप भरोसा करना चाहिए)। हालांकि, आप यह सुनिश्चित कर सकते हैं कि अगली कॉल एक बड़ी संख्या लौटाएगी और मूल्यों की तुलना करके, आप वास्तविक समय अंतर प्राप्त कर सकते हैं।
ये गुण विधि को कम से कम उपयुक्त समय में विफल होने के बिना समय अंतर को मापने के लिए एक प्रमुख उम्मीदवार बनाते हैं (उदाहरण के लिए नए साल की पूर्व संध्या में आधी रात को जब एक और छलांग लगाया जाता है)।
यहां फ़्लोट करने का समय अनावश्यक है। –