R Academy · पाठ

system.time() और proc.time()

R व्यंजकों के बीते हुए, उपयोगकर्ता और सिस्टम समय को मापें।

पाठ 1, कुल 4 में से13 चरण

system.time() और proc.time(), CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

प्रदर्शन को मापना क्यों आवश्यक है

कोड को अनुकूलित करने से पहले आपको उसका मापन करना आवश्यक है। धीमापन कहाँ है, इसका अनुमान लगाने से प्रयास व्यर्थ हो सकता है। R, expressions का सटीक समय मापने के लिए अंतर्निहित टूल उपलब्ध कराता है।

तीन मुख्य टूल हैं: system.time(), proc.time(), और Sys.time()। प्रदर्शन विश्लेषण में प्रत्येक का उद्देश्य अलग है।

system.time() की मूल बातें

system.time(expr) किसी expression का मूल्यांकन करता है और बताता है कि उसमें कितना समय लगा। R में किसी एक operation का समय मापने का यह सबसे सरल तरीका है।

परिणाम proc_time class का एक object होता है, जिसके नामित elements का आप निरीक्षण कर सकते हैं।

result <- system.time({
  x <- 1:1000000
  total <- sum(x)
})
print(result)

समय के तीन मानों को पढ़ना

system.time() पाँच मान लौटाता है, लेकिन इनमें से तीन सबसे महत्वपूर्ण हैं:

user — R code द्वारा स्वयं उपयोग किया गया CPU समय
sys — R की ओर से OS द्वारा उपयोग किया गया CPU समय
elapsed — वास्तविक घड़ी का समय (बीते हुए वास्तविक सेकंड)

आमतौर पर आपका ध्यान elapsed पर होना चाहिए। मल्टी-कोर मशीनों पर user + sys, elapsed से अधिक हो सकते हैं।

t <- system.time(Sys.sleep(0.1))
cat('user   :', t['user.self'], '
')
cat('sys    :', t['sys.self'], '
')
cat('elapsed:', t['elapsed'], '
')

मैन्युअल समय-मापन के लिए proc.time()

proc.time() वर्तमान CPU और elapsed समयों का एक snapshot लौटाता है। किसी code block से पहले और बाद में इसे कैप्चर करके आप code के किसी भी मनमाने हिस्से का समय माप सकते हैं।

उस हिस्से का elapsed समय पाने के लिए आरंभिक snapshot को अंतिम snapshot से घटाएँ।

start <- proc.time()
for (i in 1:100000) sqrt(i)
end <- proc.time()
diff <- end - start
cat('elapsed:', diff['elapsed'], 'seconds
')

proc.time() के घटक

proc.time() तीन elements वाला नामित numeric vector लौटाता है:

user.self — R process द्वारा उपयोग किया गया user CPU समय
sys.self — R process द्वारा उपयोग किया गया system CPU समय
elapsed — R के शुरू होने के बाद से बीता वास्तविक घड़ी का समय

दो proc.time() calls के बीच का अंतर उपयोगी समय-अंतर देता है।

pt <- proc.time()
cat('Names:', names(pt), '
')
cat('Values:', pt, '
')
cat('Class:', class(pt), '
')

वास्तविक घड़ी के timestamps के लिए Sys.time()

Sys.time() वर्तमान तारीख और समय को POSIXct object के रूप में लौटाता है। proc.time() के विपरीत, यह केवल CPU उपयोग नहीं, बल्कि वास्तविक दुनिया का timestamp देता है।

यह केवल यह जानने के बजाय कि कितना समय लगा, यह दर्ज करने के लिए उपयोगी है कि कुछ कब हुआ।

start_time <- Sys.time()
cat('Start:', format(start_time), '
')
Sys.sleep(0.05)
end_time <- Sys.time()
cat('End  :', format(end_time), '
')

अंतराल मापने के लिए difftime()

difftime(end, start, units='secs') दो POSIXct timestamps के बीच का अंतर निकालता है। आप units चुन सकते हैं: 'secs', 'mins', 'hours', 'days'।

पढ़ने योग्य समय-मापन output के लिए यह Sys.time() के साथ स्वाभाविक रूप से उपयोग होता है।

t1 <- Sys.time()
x <- cumsum(1:500000)
t2 <- Sys.time()
delta <- difftime(t2, t1, units = 'secs')
cat('Time taken:', round(as.numeric(delta), 4), 'seconds
')

replicate() के साथ loop में समय-मापन

garbage collection या OS scheduling के कारण एकल समय-मापन बदल सकता है। replicate(n, system.time(expr)['elapsed']) expression को कई बार चलाता है और elapsed समयों का एक vector लौटाता है।

दोहराए गए समय-मापनों का median लेने से अधिक स्थिर अनुमान मिलता है।

times <- replicate(10, system.time({
  x <- rnorm(10000)
  mean(x)
})['elapsed'])
cat('Median elapsed:', median(times), 'seconds
')
cat('Range:', range(times), '
')

दो तरीकों की तुलना

एक ही task के दो implementations की सीधे तुलना करने के लिए system.time() का उपयोग करें। यह तरीका अपनाने से पहले यह पुष्टि करने में सहायता करता है कि कोई एक तरीका अधिक तेज़ है।

n <- 100000
t_loop <- system.time({
  result <- numeric(n)
  for (i in seq_len(n)) result[i] <- i^2
})['elapsed']

t_vec <- system.time({
  result <- seq_len(n)^2
})['elapsed']

cat('Loop   :', t_loop, 's
')
cat('Vector :', t_vec, 's
')
cat('Speedup:', round(t_loop / max(t_vec, 1e-6), 1), 'x
')

नेस्टेड operations का समय-मापन

किस step में bottleneck है, यह पहचानने के लिए आप system.time() calls को nest कर सकते हैं या workflow के भीतर proc.time() checkpoints का उपयोग कर सकते हैं।

अपने pipeline की समय-रेखा बनाने के लिए script के चलने के दौरान बीच के deltas print करें।

p0 <- proc.time()
x <- rnorm(200000)
p1 <- proc.time()
y <- sort(x)
p2 <- proc.time()
z <- cumsum(y)
p3 <- proc.time()

cat('Generate:', (p1-p0)['elapsed'], 's
')
cat('Sort    :', (p2-p1)['elapsed'], 's
')
cat('Cumsum  :', (p3-p2)['elapsed'], 's
')

समय-मापन के व्यावहारिक सुझाव

R code का समय मापते समय इन तरीकों को ध्यान में रखें:

समय-मापन से पहले code को एक बार चलाएँ, ताकि JIT और file caches तैयार हो जाएँ
garbage collection की स्थिति रीसेट करने के लिए समय-मापन से पहले gc() का उपयोग करें
दोहराए गए मापनों में mean के बजाय median को प्राथमिकता दें — GC से आए outliers mean को प्रभावित करते हैं
पूरी script के बजाय bottleneck का समय मापें

gc()  # clear garbage before timing
times <- replicate(5, system.time({
  m <- matrix(rnorm(1000 * 1000), nrow = 1000)
  crossprod(m)
})['elapsed'])
cat('Median:', median(times), 's
')

त्वरित जाँच: system.time() के घटक

system.time() का कौन-सा component execution के दौरान बीते वास्तविक घड़ी के सेकंडों को दर्शाता है?

इंटरैक्टिव पाठ में इसका उत्तर दें

प्रदर्शन समय-मापन का पुनरावलोकन

अब आपके पास base R में समय-मापन के तीन पूरक टूल हैं:

system.time(expr) — एक expression का समय मापने का सबसे तेज़ तरीका; user/sys/elapsed लौटाता है
proc.time() — मनमाने code blocks के लिए snapshot-आधारित समय-मापन
Sys.time() + difftime() — वास्तविक घड़ी के timestamps और मनुष्यों के लिए पढ़ने योग्य अंतराल

प्रदर्शन के बारे में निष्कर्ष निकालने से पहले स्थिर median समय-मापन पाने के लिए replicate() का उपयोग करें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 43
पाठ: 159

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “system.time() और proc.time()” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “system.time() और proc.time()” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“system.time() और proc.time()” में मैं क्या सीखूँगा?

R व्यंजकों के बीते हुए, उपयोगकर्ता और सिस्टम समय को मापें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“system.time() और proc.time()” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← R Academy पर वापस जाएँ