अजगर का समय कितना सही है। सो ()?

Question

मैं इसे फ्लोटिंग पॉइंट नंबर दे सकता हूं, जैसे कि

time.sleep(0.5)

लेकिन यह कितना सही है? अगर मैं दे दूं

time.sleep(0.05)

क्या यह वास्तव में लगभग 50 एमएस सो जाएगा?

Answer 1

Time.sleep फ़ंक्शन की सटीकता आपके अंतर्निहित OS की नींद सटीकता पर निर्भर करती है। गैर-रीयलटाइम ओएस के लिए एक स्टॉक विंडोज की तरह सबसे छोटा अंतराल जो आप सो सकते हैं वह लगभग 10-13ms है। मैंने उस समय के कई मिलीसेकंड के भीतर सटीक नींद देखी है जब न्यूनतम 10-13ms से ऊपर होता है।

अद्यतन: जैसा कि नीचे दिए गए डॉक्स में उल्लेख किया गया है, नींद को एक लूप में करना आम है जो यह सुनिश्चित करने के लिए वापस सो जाएगा कि यदि यह आपको जल्दी जगाता है।

मुझे यह भी उल्लेख करना चाहिए कि यदि आप उबंटू चल रहे हैं, तो आप आरटी कर्नेल पैकेज (कम से कम उबंटू 10.04 एलटीएस) को स्थापित करके एक छद्म वास्तविक समय कर्नेल (आरटी_प्रेट पैच सेट के साथ) आज़मा सकते हैं।

संपादित करें: सुधार गैर-वास्तविक समय लिनक्स कर्नेल में न्यूनतम नींद अंतराल 1ms से 10ms के करीब है, लेकिन यह गैर-नियतात्मक तरीके से भिन्न होता है।

Comments

दरअसल, लिनक्स कर्नेल काफी समय से एक उच्च टिक दर के लिए डिफ़ॉल्ट है, इसलिए "न्यूनतम" नींद 10ms की तुलना में 1ms के करीब है। यह गारंटी नहीं है - अन्य सिस्टम गतिविधि कर्नेल को सीपीयू विवाद के बिना आपकी प्रक्रिया को शेड्यूल करने में असमर्थ बना सकती है। यही कारण है कि realtime गुठली को ठीक करने की कोशिश कर रहे हैं, मुझे लगता है। लेकिन, जब तक आपको वास्तव में वास्तविक व्यवहार की आवश्यकता नहीं होती है, बस एक उच्च टिक दर (कर्नेल एचजेड सेटिंग) का उपयोग करके आपको लिनक्स में कुछ विशेष उपयोग किए बिना गारंटी-लेकिन-उच्च-रिज़ॉल्यूशन नींद नहीं मिलेगी।

— ग्लेन मेनार्ड

हाँ, आप सही हैं, मैंने लिनक्स 2.6.24-24 के साथ कोशिश की और 1000 हर्ट्ज अपडेट दरों के बहुत करीब आने में सक्षम था। जब मैं यह कर रहा था उस समय मैं मैक और विंडोज पर कोड भी चला रहा था, इसलिए मैं शायद भ्रमित हो गया। मुझे पता है कि विंडोज़ XP में कम से कम 10ms की टिक दर होती है।

— जोसेफ लिसे

विंडोज 8 पर मुझे सिर्फ 2ms से कम मिलता है

— 14'14

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

— मार्मन

Answer 2

ऑपरेटिंग सिस्टम और गुठली के बीच अंतर के बारे में लोग काफी हद तक सही हैं, लेकिन मुझे उबंटू में कोई ग्रैन्युलैरिटी नहीं दिखती है और मुझे MS7 में 1 ms ग्रैन्युलैरिटी दिखाई देती है। समय के अलग क्रियान्वयन का सुझाव देते हुए सो जाएं, न कि केवल एक अलग टिक दर। क्लोजर निरीक्षण से उबंटू में 1μs की ग्रैन्युलैरिटी का पता चलता है, लेकिन यह उस समय के कारण होता है जब मैं सटीकता को मापने के लिए उपयोग करता हूं।

Comments

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

— ०५

@ जैलहि - लीनक्स एप्रोच मेरे लिए समझ में आता है: नींद वास्तव में समय की एक राशि के लिए निष्पादन प्राथमिकता का एक विमोचन है जिसके बाद आप एक बार फिर से अपने आप को अनुसूचक की इच्छा के लिए प्रस्तुत करते हैं (जो आपको तुरंत निष्पादन के लिए निर्धारित नहीं कर सकता है) ।

— underrun

आपको परिणाम कैसे मिले? क्या आपका स्रोत कोड प्रदान कर सकता है? ग्राफ समय और नींद को मापने के लिए विभिन्न टाइमर का उपयोग करने की एक कलाकृति की तरह दिखता है (सिद्धांत रूप में, आप यादृच्छिकता के स्रोत के रूप में टाइमर के बीच बहाव का उपयोग भी कर सकते हैं )।

— JFS

@ जेएफ सेबस्टियन - जो फ़ंक्शन मैंने उपयोग किया है वह socsci.ru.nl/wilberth/computer/sleepAccuracy.html में है । तीसरा ग्राफ वहां एक प्रभाव दिखाता है जो आप देखते हैं, लेकिन केवल 1 an के समान।

— विल्बर्ट

@ जेएफ सेबस्टियन I खिड़कियों पर time.clock () का उपयोग करता है

— विल्बर्ट

Answer 3

से प्रलेखन :

दूसरी ओर, सटीक time()और sleep()उनके यूनिक्स समकक्षों की तुलना में बेहतर है: समय को फ्लोटिंग पॉइंट नंबर के रूप में व्यक्त किया जाता है, time()सबसे सटीक समय उपलब्ध (यूनिक्स का उपयोग करते हुए gettimeofday उपलब्ध) देता है, और sleep()एक नॉनजरो अंश के साथ एक समय स्वीकार करेगा (यूनिक्स selectका उपयोग किया जाता है) इसे लागू करने के लिए, जहां उपलब्ध है)।

और अधिक विशेष रूप से wrt sleep():

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

Comments

क्या कोई समझा सकता है "क्योंकि कोई भी पकड़ा गया सिग्नल नींद को समाप्त कर देगा () उस सिग्नल के पकड़ने की दिनचर्या के निष्पादन के बाद"? यह किस संकेतों की ओर इशारा करता है? धन्यवाद!

— डिएगो हेरान्ज़

सिग्नल नोटिफिकेशन की तरह होते हैं जो OS मैनेज करता है ( en.wikipedia.org/wiki/Unix_signal ), इसका मतलब है कि अगर OS ​​ने सिग्नल पकड़ा है, तो उस सिग्नल का इलाज करने के बाद नींद खत्म हो जाती है।

— एरियन जेएम

Answer 4

यहाँ विल्बर्ट के उत्तर के लिए मेरा अनुगमन है: मैक ओएस एक्स योसेमाइट के लिए वही, क्योंकि इसका अभी तक उल्लेख नहीं किया गया है।

ऐसा लगता है कि आपके द्वारा अनुरोध किए जाने वाले समय का लगभग 1.25 गुना और आपके द्वारा अनुरोध किए जाने के समय और कभी-कभी 1 से 1.25 गुना के बीच सोता है। यह लगभग कभी नहीं (~ 1000 नमूनों में से दो बार) आपके द्वारा अनुरोध किए जाने के समय से 1.25 गुना अधिक सोता है।

इसके अलावा (स्पष्ट रूप से नहीं दिखाया गया है) 1.25 संबंध बहुत अच्छी तरह से पकड़ते हैं जब तक कि आप लगभग 0.2 एमएस से नीचे नहीं आते हैं, जिसके बाद यह थोड़ा फजी होने लगता है। इसके अतिरिक्त, वास्तविक समय आपके द्वारा अनुरोध किए गए समय से लगभग 5 एमएस से अधिक हो जाता है, जब अनुरोध किया गया समय 20 एमएस से ऊपर हो जाता है।

फिर, यह एक पूरी तरह से अलग कार्यान्वयन प्रतीत होता है sleep() विंडोज़ या जो भी लिनक्स कर्नेल विल्बर्ट का उपयोग कर रहा था, की तुलना में ओएस एक्स में ।

Comments

क्या आप बेंचमार्क के लिए स्रोत कोड को github / bitbucket पर अपलोड कर सकते हैं?

— JFS

मैंने इसे अपनी मशीन पर आज़माया है । परिणाम @ विल्बर के उत्तर के समान है ।

— JFS

मुझे लगता है कि नींद अपने आप में सटीक है, लेकिन मैक ओएस एक्स शेड्यूलिंग पर्याप्त नहीं है कि वह सीपीयू को तेजी से प्रदान कर सके ताकि नींद से जागने में देरी हो। यदि सही जागने का समय महत्वपूर्ण है, तो ऐसा लगता है कि नींद को वास्तव में अनुरोध किए जाने के 0.75 गुना पर सेट किया जाना चाहिए और जागने के बाद के समय की जांच करें और बार-बार कम समय तक और कम समय तक सोएं।

— मिको रानाल्टेन

Answer 5

आपको पता क्यों नहीं चला:

from datetime import datetime
import time

def check_sleep(amount):
    start = datetime.now()
    time.sleep(amount)
    end = datetime.now()
    delta = end-start
    return delta.seconds + delta.microseconds/1000000.

error = sum(abs(check_sleep(0.050)-0.050) for i in xrange(100))*10
print "Average error is %0.2fms" % error

रिकॉर्ड के लिए, मुझे अपने HTPC पर लगभग 0.1ms त्रुटि और मेरे लैपटॉप पर 2ms, दोनों लिनक्स मशीनें मिली हैं।

Comments

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

— ग्लेन मेनार्ड

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

— चींटियाँ प्लाज्मा

Answer 6

एक छोटे से सुधार, कई लोग उल्लेख करते हैं कि नींद एक संकेत द्वारा जल्दी समाप्त हो सकती है। में 3.6 डॉक्स यह कहते हैं,

संस्करण 3.5 में परिवर्तित: फ़ंक्शन अब कम से कम सेकंड में सोता है, भले ही नींद एक सिग्नल से बाधित हो, सिवाय इसके कि सिग्नल हैंडलर एक अपवाद उठाता है (देखें तर्क के लिए पीईपी 475 देखें )।

Answer 7

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

यह सुनिश्चित करने के लिए कि न्यूनतम मानक डेस्कटॉप ऑपरेटिंग सिस्टम पर आप 16ms (टाइमर ग्रैन्युलैरिटी प्लस टाइम टू रेफरेंस स्विच) के आसपास जा सकते हैं, लेकिन संभावना है कि दिए गए तर्क से% विचलन महत्वपूर्ण हो सकता है जब आप कोशिश कर रहे हों। सोने के लिए 10 मिली।

सिग्नल, जीआईएल धारण करने वाले अन्य धागे, कर्नेल शेड्यूलिंग फन, प्रोसेसर स्पीड स्टेपिंग, आदि सभी उस अवधि के साथ कहर ढा सकते हैं जब आपका धागा / प्रक्रिया वास्तव में सो जाती है।

Comments

दस्तावेज़ीकरण अन्यथा कहता है:> वास्तविक निलंबन समय उस अनुरोध से कम हो सकता है क्योंकि कोई भी पकड़ा गया संकेत उस सिग्नल के पकड़ने की दिनचर्या के निष्पादन के बाद नींद को समाप्त कर देगा।

— ग्लेन मेनार्ड

अह उचित बिंदु, पोस्ट को ठीक कर दिया, हालांकि लंबे समय तक सोना () कम लोगों की तुलना में अधिक संभावना है।

— निक बैस्टिन

ढाई साल बाद ... दस्तावेज अभी भी निहित है। विंडोज पर, सिग्नल नींद को समाप्त नहीं करेंगे ()। पायथन 3.2, WinXP SP3 पर परीक्षण किया गया।

— डेव

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

— अंकन

सिंगल और विंडोज केवल मूर्खतापूर्ण है। Windows पर Python time.sleep () Ctrl-C जैसे सामान को कैप्चर करने के लिए कंसोल पर प्रतीक्षा करता है।

— schlenk

Answer 8

यदि आपको अधिक सटीक या कम नींद की आवश्यकता है, तो अपना स्वयं का बनाने पर विचार करें:

import time

def sleep(duration, get_now=time.perf_counter):
    now = get_now()
    end = now + duration
    while now < end:
        now = get_now()

Answer 9

हाल ही में विंडोज 10. पर पायथन 3.7 पर इसका परीक्षण किया गया। परिशुद्धता 1ms के आसपास थी।

Comments

आपने इसका परीक्षण कैसे किया?

— अगस्टिन बाराचिना

Answer 10

def start(self):
    sec_arg = 10.0
    cptr = 0
    time_start = time.time()
    time_init = time.time()
    while True:
        cptr += 1
        time_start = time.time()
        time.sleep(((time_init + (sec_arg * cptr)) - time_start ))

        # AND YOUR CODE .......
        t00 = threading.Thread(name='thread_request', target=self.send_request, args=([]))
        t00.start()

नींद के तर्क को पारित करने के लिए एक चर का उपयोग न करें (), आपको गणना को सीधे नींद में डालना होगा ()

---

और मेरे टर्मिनल की वापसी

1 ─────────────────── 17: 20: 16.891 20

2 ───── 17: 20: 18.891 20

3 20 17: 20: 20.891 20

4 ─────────────────── 17: 20: 22.891 20

5 ─────────────────── 17: 20: 24.891 20

....

689 ──────────────────── 17: 43: 12.891:

690 ──────────────────── 17: 43: 14.890:

691 ──────────────────── 17: 43: 16.891:

692 ──────────────────── 17: 43: 18.890:

693 ──────────────────── 17: 43: 20.891:

...

727 ──────────────────── 17: 44: 28.891:

728 ──────────────────── 17: 44: 30.891:

729 ──────────────────── 17: 44: 32.891:

730 44 17: 44: 34.890 44

731 ──────────────────── 17: 44: 36.891: