R Academy · पाठ

Rprof और profvis से कोड का प्रोफ़ाइल विश्लेषण

पहचानें कि आपकी स्क्रिप्ट में कौन-से फ़ंक्शन सबसे अधिक समय लेते हैं।

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

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

प्रोफ़ाइलिंग क्या है

समय-मापन आपको बताता है कि code कितनी देर चलता है। प्रोफ़ाइलिंग बताती है कि उस code के भीतर समय कहाँ खर्च हो रहा है। R का profiler नियमित अंतराल पर call stack के नमूने लेता है और यह सांख्यिकीय चित्र बनाता है कि कौन-से functions महँगे हैं।

दो मुख्य टूल हैं: अंतर्निहित Rprof() और interactive profvis package।

Rprof() शुरू करना और रोकना

Rprof('output.prof', interval = 0.01) profiler शुरू करता है। यह हर 10 ms पर call-stack samples को एक file में लिखता है। अपना धीमा code चलाएँ, फिर recording रोकने के लिए Rprof(NULL) call करें।

interval argument sampling frequency को seconds में नियंत्रित करता है — छोटे मान अधिक resolution देते हैं, लेकिन बड़ी output files बनाते हैं।

# Pattern — do not run Rprof inside knitr/Quarto
# Rprof('my_profile.prof', interval = 0.01)
#
# slow_function <- function(n) {
#   x <- numeric(n)
#   for (i in seq_len(n)) x[i] <- sqrt(i)
#   sum(x)
# }
# slow_function(500000)
#
# Rprof(NULL)  # stop profiling

summaryRprof() से परिणाम पढ़ना

summaryRprof('output.prof') profiling file को parse करता है और दो data frames वाली list लौटाता है:

by.self — प्रत्येक function में स्वयं लगा समय (callees को छोड़कर)
by.total — उस function द्वारा call किए गए सभी functions सहित कुल समय

hot spots खोजने के लिए self.pct के अनुसार sort करें।

# After Rprof() run:
# prof <- summaryRprof('my_profile.prof')
# head(prof$by.self)
#
# Example output columns:
#            self.time self.pct total.time total.pct
# slow_fn        1.22     61.0       1.98      99.0
# sqrt           0.76     38.0       0.76      38.0
# sum            0.02      1.0       0.02       1.0

Self और कुल समय की तुलना

प्रोफ़ाइलिंग के लिए self और total time का अंतर समझना बहुत महत्वपूर्ण है:

Self time — function द्वारा अपनी lines चलाने में लगाया गया समय (callees की प्रतीक्षा का समय नहीं)
Total time — self time और उसके द्वारा call किए गए functions में लगा पूरा समय

किसी function का total time अधिक लेकिन self time कम है, तो वह अपनी logic के कारण नहीं, बल्कि जिन functions को वह call करता है उनके कारण धीमा है। caller के बजाय callee को optimize करें।

# Conceptual example:
# wrapper() -> process_data() -> slow_sort()
#
# total.pct: wrapper=100, process_data=90, slow_sort=85
# self.pct:  wrapper=5,   process_data=5,  slow_sort=85
#
# => slow_sort is the real bottleneck to fix.
cat('High total + low self => the culprit is a callee function
')

profvis का परिचय

profvis, Rprof() को wrap करता है और RStudio या browser में interactive HTML flame graph उपलब्ध कराता है। इसे raw summaryRprof() output की तुलना में पढ़ना बहुत आसान है।

इसे एक बार install.packages('profvis') से install करें, फिर अपने code को profvis({...}) में wrap करें।

# library(profvis)
#
# profvis({
#   n <- 200000
#   x <- numeric(n)
#   for (i in seq_len(n)) x[i] <- log(i)
#   total <- sum(x)
#   sorted <- sort(x)
# })

profvis flame graph को पढ़ना

profvis output में दो panels होते हैं:

Flame graph — horizontal bars, जहाँ width = समय; nested bars = call stack की गहराई
Data table — प्रत्येक function और source line के self और total time का sort किया जा सकने वाला दृश्य

Flame graph के नीचे मौजूद चौड़ी bars सबसे महँगे callers को दर्शाती हैं। ऊँचे stacks गहरी call chains का संकेत देते हैं।

# Reading the flame graph:
# - Each horizontal bar = one function on the call stack
# - Width proportional to time spent
# - Bottom = outermost caller, top = deepest callee
# - Click a bar to zoom in
# - 'Memory' tab shows allocation by line
cat('profvis shows self time per source line — invaluable for tight loops
')

Hot spots पहचानना

profvis output देखने के बाद flame graph में चौड़े और high self-time वाले functions खोजकर hot spots पहचानें। R में आम कारण हैं:

ऐसे unvectorized loops जो element-by-element काम करते हैं
loop में objects को बढ़ाने वाले बार-बार rbind() या c()
tight loops में बार-बार regex या string parsing

# Before fix — growing vector in loop (common hot spot)
# profvis reveals repeated reallocations:
# result <- c()
# for (i in 1:50000) result <- c(result, i^2)
#
# After fix — pre-allocated:
# result <- numeric(50000)
# for (i in 1:50000) result[i] <- i^2
cat('Pre-allocation eliminates the most common loop hot spot
')

Memory allocations की प्रोफ़ाइलिंग

Rprof, memory.profiling = TRUE के साथ memory allocations को भी track कर सकता है। profvis समय-मापन के साथ memory panel दिखाता है, जिससे आप ऐसे functions पहचान सकते हैं जो बड़े अस्थायी objects allocate करते हैं — garbage-collection pauses का यह एक प्रमुख स्रोत है।

# Memory profiling with Rprof:
# Rprof('mem.prof', interval = 0.01, memory.profiling = TRUE)
# ... slow code ...
# Rprof(NULL)
# prof <- summaryRprof('mem.prof', memory = 'both')
# head(prof$by.self)
#
# profvis also shows mem delta per line automatically
cat('Memory profiling pinpoints allocation hot spots causing GC pauses
')

वास्तविक pipeline की प्रोफ़ाइलिंग

Data pipeline पर प्रोफ़ाइलिंग व्यवस्थित रूप से लागू करें: पूरे pipeline को profvis({}) में wrap करें, सबसे धीमे stage की पहचान करें, उसे optimize करें, फिर सुधार की पुष्टि करने के लिए दोबारा प्रोफ़ाइल करें। कभी भी बिना जाँच के optimize न करें।

# Workflow:
# 1. profvis({ full_pipeline() })   => identify Stage 3 is 80% of time
# 2. Rewrite Stage 3 (vectorize / use data.table)
# 3. profvis({ full_pipeline() })   => confirm Stage 3 now < 10%
# 4. system.time({ full_pipeline() }) => confirm overall speedup
cat('Profile -> identify -> fix -> re-profile is the correct cycle
')

Rprof sampling की सीमाएँ

Rprof सांख्यिकीय sampling का उपयोग करता है, इसलिए बहुत तेज़ functions (sampling interval से तेज़) दिखाई नहीं दे सकते। बहुत छोटे expressions के micro-benchmarks के लिए इसके बजाय microbenchmark package का उपयोग करें।

इसके अलावा, Rprof R interface के नीचे चलने वाले C/C++ code की प्रोफ़ाइलिंग नहीं करता — केवल R-level call stacks दिखाई देते हैं।

# Rprof interval = 0.01s => functions faster than 10ms may not appear
# For sub-millisecond work use microbenchmark:
#   microbenchmark(expr1, expr2, times = 1000L)
#
# For C-level profiling use external tools:
#   - Instruments (macOS)
#   - perf (Linux)
cat('Rprof is for R-level profiling; use microbenchmark for micro-timing
')

R प्रोफ़ाइलिंग की सर्वोत्तम पद्धतियाँ

विश्वसनीय profiling results पाने के लिए इन तरीकों का पालन करें:

वास्तविक data sizes के साथ profile करें — छोटे inputs वास्तविक bottleneck छिपा देते हैं
एक बार होने वाली setup costs को बाहर रखने के लिए profiling से पहले warm-up iterations चलाएँ
loaded packages के हस्तक्षेप से बचने के लिए साफ़ R session में profile करें
exploration के लिए profvis और CI/automated reports के लिए summaryRprof का उपयोग करें

# Clean session profiling checklist:
# 1. Restart R (Ctrl+Shift+F10 in RStudio)
# 2. Load only required packages
# 3. Run once to warm up
# 4. profvis({ ... })  on second run
# 5. Compare before/after with system.time()
cat('Always profile with realistic data in a clean R session
')

त्वरित जाँच: Rprof में Self और Total

summaryRprof() output में किसी function के लिए total.pct = 95% लेकिन self.pct = 3% दिखाई देता है। इससे आपको क्या पता चलता है?

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

प्रोफ़ाइलिंग टूल का पुनरावलोकन

R आपको दो-स्तरीय profiling toolkit देता है:

Rprof('file.prof', interval=0.01) + Rprof(NULL) + summaryRprof() — अंतर्निहित, scriptable और CI के अनुकूल
profvis({...}) — source-line annotation और memory tracking वाला interactive flame graph

सही workflow हमेशा यह है: पहले मापें, सबसे hot spot पहचानें, केवल उसी को optimize करें, फिर लाभ की पुष्टि करने के लिए दोबारा मापें।

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

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

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

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

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

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

क्या “Rprof और profvis से कोड का प्रोफ़ाइल विश्लेषण” पाठ निःशुल्क है?

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

“Rprof और profvis से कोड का प्रोफ़ाइल विश्लेषण” में मैं क्या सीखूँगा?

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

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

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

“Rprof और profvis से कोड का प्रोफ़ाइल विश्लेषण” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

system.time() और proc.time()
Rprof और profvis से कोड का प्रोफ़ाइल विश्लेषण
गति के लिए वेक्टरकरण
microbenchmark से बेंचमार्किंग

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