0Pricing
R Academy · Lección

system.time() y proc.time()

Mida el tiempo transcurrido y el tiempo de usuario y del sistema de las expresiones de R.

system.time() y proc.time() es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

¿Por qué medir el rendimiento?

Antes de optimizar el código, debe medirlo. Adivinar dónde se produce la lentitud lleva a invertir esfuerzos en vano. R proporciona herramientas integradas para cronometrar expresiones con precisión.

Las tres herramientas principales son system.time(), proc.time() y Sys.time(). Cada una cumple una función distinta en el análisis del rendimiento.

Conceptos básicos de system.time()

system.time(expr) evalúa una expresión y devuelve cuánto tardó. Es la forma más sencilla de cronometrar una única operación en R.

El resultado es un objeto de clase proc_time con elementos con nombre que puede inspeccionar.

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

Interpretación de los tres valores de tiempo

system.time() devuelve cinco valores, pero tres son los más importantes:

  • user — tiempo de CPU utilizado por el propio código de R
  • sys — tiempo de CPU utilizado por el sistema operativo en nombre de R
  • elapsed — tiempo de reloj transcurrido (los segundos reales que pasaron)

Por lo general, el valor que le interesa es elapsed. user + sys puede superar a elapsed en máquinas con varios núcleos.

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

proc.time() para cronometrar manualmente

proc.time() devuelve una instantánea de los tiempos de CPU y transcurrido actuales. Si captura el valor antes y después de un bloque, puede cronometrar cualquier fragmento de código.

Reste la instantánea inicial de la instantánea final para obtener el tiempo transcurrido de esa sección.

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

Componentes de proc.time()

proc.time() devuelve un vector numérico con nombre y tres elementos:

  • user.self — tiempo de CPU de usuario del proceso de R
  • sys.self — tiempo de CPU del sistema del proceso de R
  • elapsed — tiempo de reloj transcurrido desde que se inició R

La diferencia entre dos llamadas a proc.time() proporciona intervalos de tiempo significativos.

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

Sys.time() para marcas de tiempo del reloj

Sys.time() devuelve la fecha y hora actuales como un objeto POSIXct. A diferencia de proc.time(), proporciona una marca de tiempo del mundo real, no solo el uso de CPU.

Esto resulta útil para registrar cuándo ocurrió algo, no solo cuánto tardó.

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

difftime() para medir intervalos

difftime(end, start, units='secs') calcula la diferencia entre dos marcas de tiempo POSIXct. Puede elegir las unidades: 'secs', 'mins', 'hours', 'days'.

Esta función se combina naturalmente con Sys.time() para obtener resultados de cronometraje fáciles de interpretar.

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

Cronometrar un bucle con replicate()

Una única medición de tiempo puede variar debido a la recolección de basura o a la planificación del sistema operativo. replicate(n, system.time(expr)['elapsed']) ejecuta la expresión varias veces y devuelve un vector de tiempos transcurridos.

Calcular la mediana de las mediciones repetidas proporciona una estimación más estable.

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

Comparación de dos enfoques

Use system.time() para comparar directamente dos implementaciones de la misma tarea. Este patrón le ayuda a confirmar que un enfoque es más rápido antes de adoptarlo.

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

Cronometrar operaciones anidadas

Puede anidar llamadas a system.time() o usar puntos de control de proc.time() dentro de un flujo de trabajo para identificar qué paso constituye el cuello de botella.

Imprima las diferencias intermedias a medida que se ejecuta el script para crear una cronología de su 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
')

Consejos prácticos para cronometrar

Tenga presentes estas prácticas al cronometrar código de R:

  • Ejecute el código una vez antes de medir para calentar la caché JIT y las cachés de archivos
  • Use gc() antes de medir para restablecer el estado de la recolección de basura
  • Prefiera la mediana a la media en varias repeticiones: los valores atípicos de GC sesgan la media
  • Mida el cuello de botella, no el script completo
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
')

Comprobación rápida: componentes de system.time()

¿Qué componente de system.time() representa los segundos reales de reloj transcurridos durante la ejecución?

Resumen de la medición del rendimiento

Ahora dispone de tres herramientas complementarias para medir tiempos en R base:

  • system.time(expr) — la forma más rápida de cronometrar una expresión; devuelve user/sys/elapsed
  • proc.time() — medición basada en instantáneas para bloques de código arbitrarios
  • Sys.time() + difftime() — marcas de tiempo del reloj e intervalos legibles

Use replicate() para obtener mediciones medianas estables antes de extraer conclusiones sobre el rendimiento.

Preguntas frecuentes

¿La lección «system.time() y proc.time()» es gratis?

Sí — el texto completo de «system.time() y proc.time()» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «system.time() y proc.time()»?

Mida el tiempo transcurrido y el tiempo de usuario y del sistema de las expresiones de R. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «system.time() y proc.time()»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. system.time() y proc.time()
  2. Análisis de rendimiento del código con Rprof y profvis
  3. Vectorización para acelerar el código
  4. Evaluación comparativa con microbenchmark
← Volver a R Academy