R Academy · Lezione

system.time() e proc.time()

Misuri il tempo trascorso e il tempo utente e di sistema per le espressioni R

Lezione 1 di 413 passaggi

system.time() e proc.time() è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Perché misurare le prestazioni?

Prima di ottimizzare il codice, è necessario misurarlo. Indovinare dove si verifica la lentezza porta a sprecare tempo e risorse. R offre strumenti integrati per cronometrare con precisione le espressioni.

I tre strumenti principali sono system.time(), proc.time() e Sys.time(). Ognuno ha uno scopo diverso nell’analisi delle prestazioni.

Nozioni di base su system.time()

system.time(expr) valuta un’espressione e restituisce il tempo impiegato. È il modo più semplice per cronometrare una singola operazione in R.

Il risultato è un oggetto della classe proc_time con elementi denominati che è possibile esaminare.

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

Interpretare i tre valori temporali

system.time() restituisce cinque valori, ma i tre più importanti sono:

user — tempo CPU utilizzato direttamente dal codice R
sys — tempo CPU utilizzato dal sistema operativo per conto di R
elapsed — tempo trascorso secondo l’orologio reale

Di solito è il valore elapsed a interessare maggiormente. Su macchine con più core, user + sys può superare elapsed.

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

proc.time() per il cronometraggio manuale

proc.time() restituisce un’istantanea dei tempi CPU e del tempo trascorso correnti. Acquisendola prima e dopo un blocco, è possibile cronometrare qualsiasi porzione di codice.

Sottragga l’istantanea iniziale da quella finale per ottenere il tempo trascorso in quella sezione.

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

Componenti di proc.time()

proc.time() restituisce un vettore numerico denominato con tre elementi:

user.self — tempo CPU utente del processo R
sys.self — tempo CPU di sistema del processo R
elapsed — tempo trascorso secondo l’orologio reale dall’avvio di R

La differenza tra due chiamate a proc.time() fornisce variazioni temporali significative.

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

Sys.time() per le marche temporali dell’orologio reale

Sys.time() restituisce la data e l’ora correnti come oggetto POSIXct. A differenza di proc.time(), fornisce una marca temporale del mondo reale, non soltanto l’utilizzo della CPU.

È utile per registrare quando è accaduto qualcosa, non solo quanto tempo ha richiesto.

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

difftime() per misurare gli intervalli

difftime(end, start, units='secs') calcola la differenza tra due marche temporali POSIXct. È possibile scegliere le unità: 'secs', 'mins', 'hours', 'days'.

Si abbina naturalmente a Sys.time() per ottenere un’uscita temporale leggibile.

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

Cronometraggio in un ciclo con replicate()

Una singola misurazione può variare a causa del garbage collection o della pianificazione del sistema operativo. replicate(n, system.time(expr)['elapsed']) esegue l’espressione più volte e restituisce un vettore dei tempi trascorsi.

Calcolare la mediana dei tempi replicati fornisce una stima più stabile.

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

Confrontare due approcci

Utilizzi system.time() per confrontare direttamente due implementazioni della stessa attività. Questo schema consente di verificare che un approccio sia più veloce prima di adottarlo.

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

Cronometrare operazioni annidate

È possibile annidare chiamate a system.time() oppure utilizzare checkpoint di proc.time() all’interno di un flusso di lavoro per identificare il passaggio che costituisce il collo di bottiglia.

Stampi le differenze intermedie mentre lo script viene eseguito per costruire una sequenza temporale della pipeline.

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

Consigli pratici per il cronometraggio

Tenga presenti queste pratiche quando cronometra codice R:

Esegua il codice una volta prima della misurazione per riscaldare la JIT e le cache dei file
Utilizzi gc() prima della misurazione per reimpostare lo stato del garbage collection
Preferisca la mediana alla media tra le ripetizioni: i valori anomali del GC distorcono la media
Misuri il collo di bottiglia, non l’intero script

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

Verifica rapida: componenti di system.time()

Quale componente di system.time() rappresenta i secondi effettivi trascorsi secondo l’orologio reale durante l’esecuzione?

Rispondi nella lezione interattiva

Riepilogo del cronometraggio delle prestazioni

Ora dispone di tre strumenti complementari per il cronometraggio in R base:

system.time(expr) — il modo più rapido per cronometrare un’espressione; restituisce user/sys/elapsed
proc.time() — cronometraggio basato su istantanee per blocchi di codice arbitrari
Sys.time() + difftime() — marche temporali dell’orologio reale e intervalli leggibili

Utilizzi replicate() per ottenere tempi mediani stabili prima di trarre conclusioni sulle prestazioni.

Gratis per iniziare

Impara R con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 43
Lezioni: 159

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «system.time() e proc.time()» è gratuita?

Sì — il testo completo di «system.time() e proc.time()» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «system.time() e proc.time()»?

Misuri il tempo trascorso e il tempo utente e di sistema per le espressioni R Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «system.time() e proc.time()»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

system.time() e proc.time()
Profilazione del codice con Rprof e profvis
Vettorizzazione per aumentare la velocità
Benchmark con microbenchmark

← Torna a R Academy