क्यों इतना धीमा करने के लिए मुद्रण है? क्या इसे बख्शा जा सकता है?

Question

मैं हमेशा से चकित / निराश रहा हूं कि प्रिंट स्टेटमेंट के साथ टर्मिनल पर बस आउटपुट करने में कितना समय लगता है। कुछ हालिया दर्दनाक धीमी लॉगिंग के बाद मैंने इसे देखने का फैसला किया और यह जानकर काफी आश्चर्यचकित हुआ कि लगभग सभी समय टर्मिनल के परिणामों के लिए इंतजार कर रहा है।

क्या स्टडआउट को लिखना किसी भी तरह से लिखा जा सकता है?

मैंने print_timer.py100k लाइन्स को stdout, फाइल करने के लिए, और stdout के साथ रीडायरेक्ट करने के लिए 100k लाइन्स लिखते समय टाइमिंग की तुलना करने के लिए एक स्क्रिप्ट (' ' इस सवाल के नीचे) लिखी /dev/null। यहाँ समय परिणाम है:

$ python print_timer.py
this is a test
this is a test
<snipped 99997 lines>
this is a test
-----
timing summary (100k lines each)
-----
print                         :11.950 s
write to file (+ fsync)       : 0.122 s
print with stdout = /dev/null : 0.050 s

वाह। यह सुनिश्चित करने के लिए कि अजगर पर्दे के पीछे से कुछ नहीं कर रहा है, जैसे कि मैं पहचानता हूं कि मैंने stdout को / dev / null या कुछ और करने के लिए आश्वस्त किया था, मैंने स्क्रिप्ट के बाहर पुनर्निर्देशन किया ...

$ python print_timer.py > /dev/null
-----
timing summary (100k lines each)
-----
print                         : 0.053 s
write to file (+fsync)        : 0.108 s
print with stdout = /dev/null : 0.045 s

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

यह मुझे याद दिलाता है कि टैटी कितनी धीमी है। यह कैसे हो सकता है कि भौतिक डिस्क पर लिखना "स्क्रीन" (संभवतः एक ऑल-रैम ऑप) लिखने की तुलना में तेज़ है, और प्रभावी रूप से उतनी ही तेजी से है जितना कि कचरा / देव / नल के साथ कचरा डंप करना?

यह लिंक इस बारे में बात करता है कि टर्मिनल I / O को कैसे अवरुद्ध करेगा ताकि यह "इनपुट को पार्स कर सके ", इसके फ्रेम बफर को अपडेट करें, विंडो को स्क्रॉल करने के लिए X सर्वर से संवाद करें और इसी तरह " ... लेकिन मैं नहीं पूरी तरह से प्राप्त करें। इतनी देर क्या हो सकती है?

मुझे उम्मीद है कि कोई रास्ता नहीं निकलेगा (तेज ट्टी कार्यान्वयन की कमी?) लेकिन आंकड़ा मैं वैसे भी पूछूंगा।

---

अद्यतन: कुछ टिप्पणियों को पढ़ने के बाद मैंने सोचा कि मेरे स्क्रीन के आकार का प्रिंट समय पर वास्तव में कितना प्रभाव है, और इसका कुछ महत्व है। ऊपर वास्तव में धीमी संख्या में मेरे गनोम टर्मिनल 1920x1200 तक उड़ा दिए गए हैं। अगर मैं इसे बहुत छोटा कर दूं तो मुझे ...

-----
timing summary (100k lines each)
-----
print                         : 2.920 s
write to file (+fsync)        : 0.121 s
print with stdout = /dev/null : 0.048 s

यह निश्चित रूप से बेहतर है (~ 4x), लेकिन मेरा सवाल नहीं बदलता है। यह केवल मेरे सवाल में जोड़ता है क्योंकि मुझे समझ में नहीं आता है कि टर्मिनल स्क्रीन रेंडरिंग को स्टैडआउट को लिखने वाले एप्लिकेशन को धीमा क्यों करना चाहिए। मेरे कार्यक्रम को जारी रखने के लिए स्क्रीन रेंडरिंग की प्रतीक्षा करने की आवश्यकता क्यों है?

क्या सभी टर्मिनल / tty ऐप्स समान नहीं बनाए गए हैं? मुझे अभी प्रयोग करना बाकी है। यह वास्तव में मुझे लगता है कि एक टर्मिनल को आने वाले सभी डेटा को बफर करने में सक्षम होना चाहिए, इसे अदृश्य रूप से पार्स / रेंडर करना चाहिए, और केवल सबसे हालिया रंक को प्रस्तुत करना चाहिए जो एक समझदार फ्रेम दर पर वर्तमान स्क्रीन कॉन्फ़िगरेशन में दिखाई देता है। इसलिए अगर मैं ~ 0.1 सेकंड में डिस्क पर fsync लिख सकता हूं, तो एक टर्मिनल को उसी ऑर्डर में से कुछ में उसी ऑपरेशन को पूरा करने में सक्षम होना चाहिए (ऐसा करते समय शायद कुछ स्क्रीन अपडेट के साथ)।

मैं अभी भी उम्मीद कर रहा हूं कि एक ट्टी सेटिंग है जिसे प्रोग्रामर के लिए इस व्यवहार को बेहतर बनाने के लिए एप्लिकेशन पक्ष से बदला जा सकता है। यदि यह कड़ाई से एक टर्मिनल आवेदन मुद्दा है, तो यह शायद StackOverflow पर भी नहीं है?

मैं क्या खो रहा हूँ?

---

यहाँ समय उत्पन्न करने के लिए अजगर कार्यक्रम का उपयोग किया जाता है:

import time, sys, tty
import os

lineCount = 100000
line = "this is a test"
summary = ""

cmd = "print"
startTime_s = time.time()
for x in range(lineCount):
    print line
t = time.time() - startTime_s
summary += "%-30s:%6.3f s\n" % (cmd, t)

#Add a newline to match line outputs above...
line += "\n"

cmd = "write to file (+fsync)"
fp = file("out.txt", "w")
startTime_s = time.time()
for x in range(lineCount):
    fp.write(line)
os.fsync(fp.fileno())
t = time.time() - startTime_s
summary += "%-30s:%6.3f s\n" % (cmd, t)

cmd = "print with stdout = /dev/null"
sys.stdout = file(os.devnull, "w")
startTime_s = time.time()
for x in range(lineCount):
    fp.write(line)
t = time.time() - startTime_s
summary += "%-30s:%6.3f s\n" % (cmd, t)

print >> sys.stderr, "-----"
print >> sys.stderr, "timing summary (100k lines each)"
print >> sys.stderr, "-----"
print >> sys.stderr, summary

Comments

स्टडआउट लिखने का पूरा उद्देश्य इतना है कि एक मानव आउटपुट पढ़ सकता है। दुनिया का कोई भी इंसान १२ सेकंड में १०,००० लाइनों के पाठ को नहीं पढ़ सकता है, तो तेज गति से काम करने का क्या मतलब है ???

— ओसुवा

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

— रस

प्रिंट स्टेटमेंट डीबगिंग उन कारणों में से एक है जिनके कारण ब्लॉक बफ़रिंग के बजाय tty डिवाइसेस (यानी टर्मिनल) डिफ़ॉल्ट रूप से लाइन बफ़रिंग करने के लिए डिफ़ॉल्ट हैं: डिबग आउटपुट का बहुत उपयोग नहीं होता है यदि प्रोग्राम हैंग होता है और डीबग आउटपुट की अंतिम कुछ पंक्तियाँ अभी भी एक बफर में हैं इसके बजाय टर्मिनल के लिए flushed।

— स्टीफन सी। स्टील

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

— रस

कभी-कभी बहुत लंबे समय तक चलने वाले कार्यक्रमों के लिए, मैं हर n सेकंड में करंट लाइन को प्रिंट करूँगा - शाप ऐप में ताज़ा विलंब होने के समान। यह बिल्कुल सही नहीं है, लेकिन मुझे इस बात का अंदाजा है कि मैं एक समय में एक बार कहां हूं।

— राकुल्ला २ r'१५ को २०:२

Answer 1

यह कैसे हो सकता है कि भौतिक डिस्क पर लिखना "स्क्रीन" (संभवतः एक ऑल-रैम ऑप) लिखने की तुलना में तेज़ है, और प्रभावी रूप से उतनी ही तेजी से है जितना कि कचरा / देव / नल के साथ कचरा डंप करना?

बधाई हो, आपने सिर्फ I / O बफरिंग के महत्व का पता लगाया है। :-)

डिस्क तेजी से दिखाई देती है, क्योंकि यह अत्यधिक बफर है: write()कुछ भी वास्तव में भौतिक डिस्क पर लिखे जाने से पहले अजगर के सभी कॉल वापस आ रहे हैं। (ओएस बाद में ऐसा करता है, कई हजारों लोगों के संयोजन एक बड़े, कुशल विखंडू में लिखते हैं।)

दूसरी ओर, टर्मिनल बहुत कम या कोई बफरिंग नहीं करता है: प्रत्येक व्यक्ति print/ पूरा लिखने के write(line)लिए प्रतीक्षा करता है (यानी आउटपुट डिवाइस के लिए प्रदर्शन)।

तुलना निष्पक्ष बनाने के लिए, आपको फ़ाइल परीक्षण को टर्मिनल के समान आउटपुट बफ़रिंग का उपयोग करना चाहिए, जिसे आप इस उदाहरण में संशोधित करके कर सकते हैं:

fp = file("out.txt", "w", 1)   # line-buffered, like stdout
[...]
for x in range(lineCount):
    fp.write(line)
    os.fsync(fp.fileno())      # wait for the write to actually complete

मैंने आपकी मशीन पर अपनी फ़ाइल लेखन परीक्षा चलाई, और बफरिंग के साथ, यह भी 100,000 लाइनों के लिए यहां 0.05s है।

हालांकि, उपरोक्त संशोधनों के साथ अप्रकाशित लिखने के लिए, डिस्क पर केवल 1,000 लाइनें लिखने में 40 सेकंड लगते हैं। मैंने लिखने के लिए 100,000 पंक्तियों का इंतजार करना छोड़ दिया, लेकिन पहले की तुलना में, यह एक घंटे से अधिक समय लेगी ।

टर्मिनल के 11 सेकंड को परिप्रेक्ष्य में रखता है, है ना?

इसलिए आपके मूल प्रश्न का उत्तर देने के लिए, टर्मिनल पर लिखना वास्तव में बहुत तेज़ी से तेज़ है, सभी चीजों पर विचार किया गया है, और इसे बहुत तेज़ बनाने के लिए बहुत जगह नहीं है (लेकिन व्यक्तिगत टर्मिनलों में वे कितने काम करते हैं, इस पर रेज़ की टिप्पणी देखें; जवाब)।

(आप डिस्क I / O के साथ और अधिक लेखन बफरिंग जोड़ सकते हैं, लेकिन तब आपको यह नहीं दिखाई देगा कि बफर के फ्लश होने के बाद तक आपके टर्मिनल को क्या लिखा गया था। यह एक व्यापार-बंद: अन्तरक्रियाशीलता बनाम थोक दक्षता है।)

Comments

मुझे I / O बफरिंग मिलती है ... आपने निश्चित रूप से मुझे याद दिलाया है कि मेरे पास पूरा होने के समय की सही तुलना के लिए fsync'd है (मैं प्रश्न को अपडेट करूंगा), लेकिन प्रति पंक्ति एक fsync पागलपन है। क्या एक ट्टी को वास्तव में प्रभावी रूप से ऐसा करने की आवश्यकता है? क्या कोई टर्मिनल / ओएस-साइड बफरिंग फ़ाइलों के लिए बराबर नहीं है? यानी: एप्लिकेशन स्टैडआउट को लिखते हैं और टर्मिनल रेंडर करने से पहले स्क्रीन पर लौटते हैं, टर्मिनल (या ओएस) के साथ यह सब बफ़र कर रहा है। टर्मिनल तब समझदारी से एक दृश्य फ्रेम दर पर स्क्रीन को पूंछ सौंप सकता है। हर लाइन पर प्रभावी रूप से ब्लॉक करना मूर्खतापूर्ण लगता है। मुझे लगता है कि मैं अभी भी कुछ याद कर रहा हूं।

— रस

तुम सिर्फ एक बड़ा बफर के साथ अपने आप को संभालने के लिए एक हैंडल खोल सकते हैं, जैसे कुछ का उपयोग कर os.fdopen(sys.stdout.fileno(), 'w', BIGNUM)। यह लगभग कभी भी उपयोगी नहीं होगा, हालांकि: लगभग सभी अनुप्रयोगों को उपयोगकर्ता-इच्छित आउटपुट की प्रत्येक पंक्ति के बाद स्पष्ट रूप से फ्लश करना याद रखना होगा।

— पाई डेलपोर्ट

मैंने पहले विशाल (10 एमबी तक fp = os.fdopen(sys.__stdout__.fileno(), 'w', 10000000)) अजगर-साइड बफ़र्स के साथ प्रयोग किया था । प्रभाव शून्य था। यानी: अभी भी लंबे समय तक देरी। इसने मुझे यह महसूस / एहसास कराया कि आप धीमी ट्टी की समस्या को स्थगित कर देते हैं ... जब अजगर का बफर आखिरकार ट्टी को प्रवाहित कर देता है तो वापस लौटने से पहले स्ट्रीम पर उसी कुल प्रसंस्करण को लगता है।

— रस्स

ध्यान दें कि यह उत्तर भ्रामक और गलत है (क्षमा करें!)। विशेष रूप से यह कहना गलत है कि "इसे बनाने के लिए बहुत अधिक जगह नहीं है [11 सेकंड से अधिक]"। कृपया इस सवाल का अपना जवाब देखें जहां मैं दिखाता हूं कि wterm टर्मिनल ने 0.26 में समान 11s परिणाम प्राप्त किया।

— रस

रस: प्रतिक्रिया के लिए धन्यवाद! मेरी तरफ, एक बड़े fdopenबफर (2 एमबी) ने निश्चित रूप से एक बड़ा अंतर बनाया: यह मुद्रण समय को कई सेकंड से 0.05 के दशक तक ले गया, जो फ़ाइल आउटपुट (उपयोग gnome-terminal) के समान है।

— पाई डेलपोर्ट

Answer 2

सभी टिप्पणियों के लिए धन्यवाद! मैंने आपकी सहायता से स्वयं इसका उत्तर देना समाप्त कर दिया है। हालांकि यह आपके खुद के सवाल का जवाब देने में गंदा लगता है।

प्रश्न 1: मुद्रण को धीमा क्यों करना है?

उत्तर: stdout में मुद्रण स्वाभाविक रूप से धीमा नहीं है । यह वह टर्मिनल है जिसके साथ आप काम करते हैं, यह धीमा है। और यह आवेदन पक्ष पर I / O बफरिंग के साथ करने के लिए बहुत अधिक शून्य है (उदाहरण: अजगर फ़ाइल बफरिंग)। निचे देखो।

प्रश्न 2: क्या इसे उगाया जा सकता है?

उत्तर: हाँ, यह प्रतीत हो सकता है, लेकिन प्रोग्राम की तरफ से नहीं (साइड 'स्टडआउट करने के लिए मुद्रण') से प्रतीत होता है। इसे तेज करने के लिए, तेजी से अलग टर्मिनल एमुलेटर का उपयोग करें।

स्पष्टीकरण ...

मैं एक स्व-वर्णित 'हल्के' टर्मिनल कहा जाता कार्यक्रम की कोशिश की wtermऔर मिल गया काफी बेहतर परिणाम। नीचे मेरी परीक्षण स्क्रिप्ट का उत्पादन (प्रश्न के निचले भाग में) जब wterm1920x1200 में उसी सिस्टम पर चल रहा है , जहां बेसिक प्रिंट विकल्प ने gnome-टर्मिनल का उपयोग करके 12s लिया:

-----
समयावधि सारांश (100k लाइनें प्रत्येक)
-----
प्रिंट: 0.261 एस
फ़ाइल (+ fsync) को लिखें: 0.110 एस
stdout = / dev / null के साथ प्रिंट करें: NAB s

0.26s 12s से बेहतर है! मुझे नहीं पता कि wtermयह कैसे समझ में आता है कि यह कैसे मैं सुझाव दे रहा था की तर्ज पर स्क्रीन के साथ प्रदान करता है (उचित फ्रेम दर पर 'दृश्यमान' पूंछ प्रदान करें), या क्या यह "से कम" करता है gnome-terminal। मेरे प्रश्न के प्रयोजनों के लिए मुझे उत्तर मिल गया है, हालांकि। gnome-terminalधीमा है।

इसलिए - यदि आपके पास एक लंबी चलने वाली स्क्रिप्ट है जिसे आप महसूस करते हैं कि यह धीमा है और यह पाठ की भारी मात्रा को stdout में फैला देता है ... एक अलग टर्मिनल आज़माएं और देखें कि क्या यह किसी भी बेहतर है!

ध्यान दें कि मैं बहुत यादृच्छिक रूप wtermसे ubuntu / debian रिपॉजिटरी से खींच लिया गया। यह लिंक एक ही टर्मिनल हो सकता है, लेकिन मुझे यकीन नहीं है। मैंने किसी अन्य टर्मिनल एमुलेटर का परीक्षण नहीं किया।

---

अद्यतन: क्योंकि मुझे खुजली को दूर करना था, मैंने एक ही स्क्रिप्ट और पूर्ण स्क्रीन (1920x1200) के साथ अन्य टर्मिनल एमुलेटरों के पूरे ढेर का परीक्षण किया। मेरे मैन्युअल रूप से एकत्रित आँकड़े यहाँ हैं:

wterm 0.3s
aterm 0.3s
rxvt 0.3s
mrxvt 0.4s
konsole 0.6s
याकुआक ०.s०
lxterminal 7 एस
एक्सटरम 9 एस
सूक्ति- टर्मिनल १२ से
xfce4-टर्मिनल 12s
वैल-टर्मिनल 18 एस
xvt 48

रिकॉर्ड किए गए समय को मैन्युअल रूप से एकत्र किया जाता है, लेकिन वे बहुत सुसंगत थे। मैंने सबसे अच्छा (ईश) मान दर्ज किया। YMMV, जाहिर है।

एक बोनस के रूप में, यह वहां उपलब्ध विभिन्न टर्मिनल एमुलेटरों में से कुछ का एक दिलचस्प दौरा था! मैं चकित हूं कि मेरा पहला 'वैकल्पिक' परीक्षण गुच्छा का सबसे अच्छा निकला।

Comments

आप एटरम भी आजमा सकते हैं। आपकी स्क्रिप्ट का उपयोग करके मेरे परीक्षण के परिणाम यहां दिए गए हैं। Aterm - प्रिंट: 0.491 s, फ़ाइल (+ fsync) को लिखें: 0.110 s, stdout = / dev / null के साथ प्रिंट करें: 0.087 s wterm - प्रिंट: 0.521 s, फ़ाइल को लिखें (+ fyync): 0.105 s, प्रिंटआउट के साथ प्रिंट करें = / देव / नल:

— ०.० s५

Urxvt की तुलना rxvt से कैसे होती है?

— डेन्थ

इसके अलावा, screen(कार्यक्रम) सूची में शामिल किया जाना चाहिए! (या byobu, जो screenएन्हांसमेंट के लिए एक आवरण है ) यह उपयोगिता कई टर्मिनलों की अनुमति देता है, एक्स टर्मिनलों में टैब की तरह। मुझे लगता है कि वर्तमान screenटर्मिनल के लिए मुद्रण एक सादे एक करने के लिए मुद्रण के रूप में ही है, लेकिन क्या एक screenटर्मिनल में मुद्रण के बारे में और फिर कोई गतिविधि के साथ दूसरे में स्विच?

— अरमांडो पेरेज़ मार्केज़

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

— टॉमस प्रूजिना

OSX पर iTerm2 ने मुझे दिया print: 0.587 s, write to file (+fsync): 0.034 s, print with stdout = /dev/null : 0.041 s:। और iTerm2 में चल रही 'स्क्रीन' के साथ:print: 1.286 s, write to file (+fsync): 0.043 s, print with stdout = /dev/null : 0.033 s

— rkulla

Answer 3

आपका पुनर्निर्देशन शायद कुछ भी नहीं करता है क्योंकि प्रोग्राम यह निर्धारित कर सकते हैं कि उनका आउटपुट एफडी एक ट्टी को इंगित करता है या नहीं।

यह संभावना है कि जब एक टर्मिनल (सी के stdoutधारा व्यवहार के समान) की ओर इशारा करते हुए स्टडआउट लाइन बफ़र किया जाता है ।

एक मनोरंजक प्रयोग के रूप में, आउटपुट को पाइप करने का प्रयास करें cat।

---

मैंने अपने खुद के मनोरंजक प्रयोग की कोशिश की है, और यहाँ परिणाम हैं।

$ python test.py 2>foo
...
$ cat foo
-----
timing summary (100k lines each)
-----
print                         : 6.040 s
write to file                 : 0.122 s
print with stdout = /dev/null : 0.121 s

$ python test.py 2>foo |cat
...
$ cat foo
-----
timing summary (100k lines each)
-----
print                         : 1.024 s
write to file                 : 0.131 s
print with stdout = /dev/null : 0.122 s

Comments

मैंने अजगर को इसके आउटपुट एफएस की जांच करने के बारे में नहीं सोचा था। मुझे आश्चर्य है कि अगर अजगर पर्दे के पीछे एक चाल खींच रहा है? मुझे उम्मीद है, लेकिन पता नहीं है।

— रस्स

+1 बफ़रिंग में सभी महत्वपूर्ण अंतर को इंगित करने के लिए

— पीटर जी।

@Russ: -uऑप्शन फोर्स stdin, stdoutऔर अनफिल्टर्ड stderrहोने के लिए, जो कि ब्लॉक

— बफर्ड

Answer 4

मैं तकनीकी विवरणों के बारे में बात नहीं कर सकता क्योंकि मैं उन्हें नहीं जानता, लेकिन इससे मुझे कोई आश्चर्य नहीं है: टर्मिनल को इस तरह बहुत सारे डेटा को प्रिंट करने के लिए डिज़ाइन नहीं किया गया था। वास्तव में, आप जीयूआई सामान के भार का लिंक भी प्रदान करते हैं, जो आपको हर बार कुछ प्रिंट करने के लिए करना होता है! ध्यान दें कि यदि आप pythonwइसके बजाय स्क्रिप्ट को कॉल करते हैं , तो यह 15 सेकंड नहीं लेता है; यह पूरी तरह से एक जीयूआई मुद्दा है। इससे stdoutबचने के लिए किसी फ़ाइल पर रीडायरेक्ट करें:

import contextlib, io
@contextlib.contextmanager
def redirect_stdout(stream):
    import sys
    sys.stdout = stream
    yield
    sys.stdout = sys.__stdout__

output = io.StringIO
with redirect_stdout(output):
    ...

Answer 5

टर्मिनल पर छपाई धीमी गति से होने जा रही है। दुर्भाग्य से एक नया टर्मिनल कार्यान्वयन लिखने से कम मैं वास्तव में यह नहीं देख सकता कि आप इसे कैसे गति देंगे।

Answer 6

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

Comments

सच! इसने मुझे अपने टर्मिनल विंडो का आकार (गनोम में) कुछ सज़ा (1920x1200) से कम करने का प्रयास करने के लिए प्रेरित किया। निश्चित रूप से पर्याप्त ... 2.8 प्रिंट समय बनाम 11.5 एस। बहुत बेहतर, लेकिन फिर भी ... यह क्यों रुक रहा है? आपको लगता है कि स्टडआउट बफर (हम्म) सभी 100k लाइनों को संभाल सकता है और टर्मिनल डिस्प्ले बस बफर के टेल एंड से ऑनस्क्रीन फिट होने वाली चीज़ को हड़प सकता है और इसे एक त्वरित शॉट में प्राप्त कर सकता है।

— रस्स

Xterm (या gterm, इस मामले में) आपकी अंतिम स्क्रीन को तेजी से प्रस्तुत करेगा यदि यह नहीं सोचा था कि इसे अन्य आउटपुट के साथ-साथ सभी को प्रदर्शित करना था। अगर इस मार्ग पर जाने की कोशिश की जाती तो यह छोटे स्क्रीन अपडेट के सामान्य मामले को कम प्रतिक्रियाशील लगता। इस प्रकार के सॉफ़्टवेयर को लिखते समय आप कभी-कभी अलग-अलग मोड्स के साथ इससे निपट सकते हैं और यह पता लगाने की कोशिश कर सकते हैं कि आपको ऑपरेशन के एक छोटे से थोक मोड में / से आगे बढ़ने की आवश्यकता है या नहीं। आप इस गति के लिए cat big_file | tailया cat big_file | tee big_file.cpy | tailबहुत बार उपयोग कर सकते हैं ।

— nategoose