R Academy · Lektion

Profilera kod med Rprof och profvis

Identifiera vilka funktioner som tar mest tid i era skript.

Lektion 2 av 413 steg

Profilera kod med Rprof och profvis är en gratis lektion i R Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.

Vad är profilering?

Tidsmätning visar hur länge koden körs. Profilering visar var tiden används i koden. R:s profilerare samplar anropsstacken med jämna mellanrum för att skapa en statistisk bild av vilka funktioner som är kostsamma.

De två viktigaste verktygen är det inbyggda Rprof() och det interaktiva paketet profvis.

Starta och stoppa Rprof()

Rprof('output.prof', interval = 0.01) startar profileraren. Den skriver prover från anropsstacken till en fil var tionde millisekund. Kör den långsamma koden och anropa sedan Rprof(NULL) för att stoppa inspelningen.

Argumentet interval styr samplingsfrekvensen i sekunder — mindre värden ger högre upplösning men större utdatafiler.

# 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

Läsa resultat med summaryRprof()

summaryRprof('output.prof') tolkar profileringsfilen och returnerar en lista med två dataramar:

by.self — tid som varje funktion själv använder (utan anropade funktioner)
by.total — total tid, inklusive alla funktioner som funktionen anropar

Sortera efter self.pct för att hitta prestandaflaskhalsar.

# 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

Egen tid kontra total tid

Det är viktigt att förstå skillnaden mellan egen tid och total tid vid profilering:

Egen tid — tiden som funktionen använder för att köra sina egna rader (utan att vänta på anropade funktioner)
Total tid — egen tid plus all tid som används i funktioner som den anropar

En funktion med hög total tid men låg egen tid är långsam på grund av det den anropar, inte på grund av sin egen logik. Optimera den anropade funktionen, inte anroparen.

# 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
')

Introduktion till profvis

profvis kapslar in Rprof() och tillhandahåller ett interaktivt HTML-flamdiagram i RStudio eller en webbläsare. Det är betydligt enklare att läsa än råutdata från summaryRprof().

Installera det en gång med install.packages('profvis') och kapsla sedan in koden med profvis({...}).

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

Läsa profvis-flamdiagrammet

Utdata från profvis har två paneler:

Flamdiagram — horisontella staplar där bredden = tid; nästlade staplar = anropsstackens djup
Datatabell — sorterbar vy över egen tid och total tid per funktion och källkodrad

Breda staplar längst ned i flamdiagrammet är de mest kostsamma anroparna. Höga staplar visar djupa anropskedjor.

# 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
')

Identifiera prestandaflaskhalsar

När Ni har granskat utdata från profvis identifierar Ni prestandaflaskhalsar genom att leta efter funktioner som är breda i flamdiagrammet och har hög egen tid. Vanliga orsaker i R:

Vektoriserade loopar som utför arbete element för element
Upprepade rbind() eller c() som växer objekt i en loop
Upprepad reguljärexpressions- eller strängparsning i täta loopar

# 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
')

Profilera minnesallokeringar

Rprof kan även spåra minnesallokeringar med memory.profiling = TRUE. profvis visar en minnespanel bredvid tidsinformationen, så att Ni kan upptäcka funktioner som allokerar stora temporära objekt — en viktig källa till pauser för skräpsamling.

# 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
')

Profilera en verklig pipeline

Tillämpa profilering systematiskt på en datapipeline: kapsla in hela pipelinen i profvis({}), identifiera det långsammaste steget, optimera det och profilera sedan igen för att bekräfta förbättringen. Optimera aldrig på måfå.

# 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
')

Begränsningar hos Rprof-sampling

Rprof använder statistisk sampling, så mycket snabba funktioner (snabbare än samplingsintervallet) kanske inte visas. För mikromätningar av mycket små uttryck kan Ni i stället använda paketet microbenchmark.

Rprof profilerar inte heller C/C++-kod under R-gränssnittet — endast anropsstackar på R-nivå är synliga.

# 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
')

Bästa metoder för R-profilering

Följ dessa metoder för att få tillförlitliga profileringsresultat:

Profilera med realistiska datamängder — små indata döljer den verkliga flaskhalsen
Kör uppvärmningsiterationer före profileringen för att utesluta kostnader för engångsinitiering
Profilera i en ren R-session för att undvika störningar från inlästa paket
Använd profvis för utforskning och summaryRprof för CI- eller automatiserade rapporter

# 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
')

Snabbkontroll: Rprof – egen tid kontra total tid

En funktion visar total.pct = 95% men self.pct = 3% i utdata från summaryRprof(). Vad innebär det?

Besvara frågan i den interaktiva lektionen

Sammanfattning av profileringsverktyg

R ger Er en profileringsverktygslåda i två nivåer:

Rprof('file.prof', interval=0.01) + Rprof(NULL) + summaryRprof() — inbyggt, skriptbart och CI-vänligt
profvis({...}) — interaktivt flamdiagram med källkodsanmärkningar och minnesspårning

Det korrekta arbetsflödet är alltid: mät först, identifiera den största flaskhalsen, optimera endast den och mät sedan igen för att bekräfta förbättringen.

Gratis att börja

Lär dig R med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 43
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Profilera kod med Rprof och profvis” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Profilera kod med Rprof och profvis”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Profilera kod med Rprof och profvis”?

Identifiera vilka funktioner som tar mest tid i era skript. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig R Academy?

Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Profilera kod med Rprof och profvis”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här R Academy-lektionen?

Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till R Academy