मैं एक सर्वर कार्यान्वयन की समीक्षा कर रहा हूं जो प्रत्येक अनुरोध संसाधित होने के लिए समय (एनयूएलएल) कहता है। मुझे आश्चर्य है कि कॉलिंग समय (एनयूएलएल) पर एक सामान्य लिनक्स सिस्टम पर क्या प्रभाव पड़ता है और यदि दिन निर्धारित करने के लिए सस्ता आदेश हैं - या आम तौर पर आप कितनी बार समय() कहते हैं?सर्वर लूप में कॉलिंग समय (एनयूएलएल) कितना महंगा है?
विषय पर आपकी राय के लिए धन्यवाद।
यह एक सिस्टम कॉल है, जैसे अन्य सवालों के जवाब में कहा, और अन्य उत्तर आप अपने सिस्टम पर लागत को मापने का एक अच्छा तरीका दे। (एक बार कर्नेल में इसे ज्यादा काम नहीं करना पड़ता है, इसलिए यह शुद्ध सिस्कल ओवरहेड की लागत के करीब है। और लिनक्स ने सिस्कोल को प्रभावी ढंग से कार्यान्वित करने के लिए क्या किया है। इस अर्थ में, आप इसे अच्छी तरह से देख सकते हैं अनुकूलित।)
अन्य उत्तरों के विपरीत, मैं इस बारे में चिंता करने योग्य नहीं होने के कारण इतना सस्ता नहीं मानूंगा। यदि यह एक आंतरिक पाश में है, तो यह इस बात पर निर्भर करता है कि आप अपने आंतरिक लूप में और क्या कर रहे हैं। यदि यह एक सर्वर प्रसंस्करण अनुरोध है, तो यह शायद प्रति अनुरोध कई सिस्कोल कर रहा है, और वास्तव में प्रत्येक अनुरोध की लागत में एक बदलाव नहीं होगा। हालांकि, मैंने कोड देखा है जहां कॉलिंग समय() (या gettimeofday(), जो वास्तव में इसे उबालता है) से syscall ओवरहेड एक हानिकारक प्रभाव पड़ता है।
आप लागत के बारे में चिंतित हैं, अपने आप से पूछना करने के लिए अगले बात क्या समय को खोजने का सस्ता तरीके उपलब्ध हैं। आम तौर पर, एक सस्ता अच्छा तरीका नहीं होने वाला है। यदि आप x86 पर हैं, तो आप सीपीयू को rdtsc निर्देश के साथ पूछ सकते हैं (और अन्य सीपीयू आर्किटेक्चर पर एनालॉग होने की संभावना है) - यह एक एकल असेंबली निर्देश है जिसे विशेषाधिकार नहीं दिया गया है ताकि आप इसे कहीं भी अपने कोड में छोड़ सकें। लेकिन बहुत सारे नुकसान हैं - rdtsc हमेशा अनुमानित दर पर नहीं बढ़ता है, खासकर अगर सीपीयू की गति बिजली प्रबंधन के लिए बदलती है, तो आप जिस सीपीयू का उपयोग कर रहे हैं उसके सटीक मॉडल के आधार पर; मानों को एकाधिक सीपीयू, आदि में सिंक्रनाइज़ नहीं किया जा सकता है। ओएस यह सब ट्रैक रखता है और जब आप gettimeofday() को कॉल करते हैं तो जानकारी के अनुकूल, उपयोग में आसान संस्करण प्रदान करेंगे।
इस वास्तव अपने टोंटी है? मैं बदले में प्रोफाइलिंग का सुझाव दूंगा। वर्तमान समय प्राप्त करना बहुत आम ऑपरेशन है और मुझे अत्यधिक संदेह है कि यह महंगा है (हालांकि आप इसे मापने के लिए आसानी से एक प्रोग्राम लिख सकते हैं)। उदाहरण के लिए, सभी वेबसर्वर इसे अपने लॉगफाइल के लिए प्रत्येक अनुरोध पर करते हैं।
यह कर्नेल में बहुत अधिक प्रोसेस किए बिना केवल एक सिस्कोल है। समय() कोई फर्क नहीं पड़ता अगर आपका सर्वर उपयोगकर्ता को फ़ाइल भेजता है, जो 100 पढ़ता है()/लिखें() एस या ऐसा कुछ करता है।
वर्तमान समय को प्राप्त करने में लिनक्स को सिस्टम कॉल शामिल है।
#include <time.h>
int main(void)
{
int i;
for (i = 0; i < 10000000; i++)
time(NULL);
return 0;
}
इस कार्यक्रम चल रहा है मेरी कायर 1.6GHz एटम 330 पर 6.26s लेता है एक 64-बिट कर्नेल के साथ, प्रति कॉल लगभग 1002 CPU चक्र के बराबर (6.26s: Vilx द्वारा sugested रूप में, यह नहीं बल्कि बेंचमार्क के लिए आसान है * 1.6 जी चक्र प्रति सेकेंड/10 एम इटर्स ≈ 1002 चक्र)।
यह निश्चित रूप से दूसरों द्वारा ध्यान में रखते हुए बहुत अधिक चिंता का वारंट नहीं करता है।
यह निश्चित रूप से एक बाधा नहीं है, लेकिन मुझे आश्चर्य है कि प्रसंस्करण समय के संदर्भ में क्या प्रभाव है। मुझे लगता है कि यह एक बेहद अनुकूलित कॉल है, लेकिन आश्चर्य है कि अगर किसी के पास इस बारे में स्पष्ट जानकारी है। – anselm
@anselm - मुझे संदेह है कि किसी ने इस कार्य को पहले प्रदर्शन समस्या के रूप में देखा है। आप इसे बेंचमार्क क्यों नहीं करते? –
मुझे किसी शर्त है। मैंने कभी भी 'टाइम' को विशेष रूप से नहीं देखा है, लेकिन मुझे जावा फंक्शन 'System.getCurrentTimeMillis' के प्रदर्शन की जांच करनी पड़ी, क्योंकि एक ग्राहक ने दावा किया कि हमारा कार्यान्वयन एक बाधा था।जो यह नहीं था, मैं जोड़ सकता हूं, वे सिर्फ अपने कोड का विश्लेषण नहीं कर रहे थे। लेकिन सिस्टम समय प्राप्त करना वास्तव में विंडोज़ पर धीमा था (कई एमएस आईआईआरसी, लेकिन मैं गलत हो सकता था), और मुझे लिनक्स पर तेज़ी से लगता है। बहुत समय पहले, हालांकि। –