R Academy · Aula

system.time() e proc.time()

Meça o tempo decorrido, do usuário e do sistema para expressões do R.

system.time() e proc.time() é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Por que medir o desempenho?

Antes de otimizar o código, é necessário medi-lo. Tentar adivinhar onde está a lentidão leva a esforços desperdiçados. R fornece ferramentas integradas para cronometrar expressões com precisão.

As três ferramentas principais são system.time(), proc.time() e Sys.time(). Cada uma tem uma finalidade diferente na análise de desempenho.

Noções básicas de system.time()

system.time(expr) avalia uma expressão e informa quanto tempo ela levou. É a maneira mais simples de cronometrar uma única operação em R.

O resultado é um objeto da classe proc_time com elementos nomeados que você pode inspecionar.

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

Interpretando os três valores de tempo

system.time() retorna cinco valores, mas três são os mais importantes:

user — tempo de CPU usado pelo próprio código R
sys — tempo de CPU usado pelo sistema operacional em nome de R
elapsed — tempo do relógio de parede (os segundos reais transcorridos)

Geralmente, o valor de elapsed é o que mais importa. User + sys podem exceder elapsed em máquinas com vários 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 cronometragem manual

proc.time() retorna os tempos atuais de CPU e transcorrido como um instantâneo. Ao capturá-lo antes e depois de um bloco, você pode cronometrar qualquer trecho arbitrário de código.

Subtraia o instantâneo inicial do instantâneo final para obter o tempo transcorrido nessa seção.

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() retorna um vetor numérico nomeado com três elementos:

user.self — tempo de CPU do usuário para o processo R
sys.self — tempo de CPU do sistema para o processo R
elapsed — tempo do relógio de parede desde o início de R

A diferença entre duas chamadas a proc.time() fornece variações de tempo significativas.

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

Sys.time() para marcas de tempo do relógio de parede

Sys.time() retorna a data e a hora atuais como um objeto POSIXct. Diferentemente de proc.time(), ele fornece uma marca de tempo do mundo real, não apenas o uso da CPU.

Isso é útil para registrar quando algo aconteceu, e não apenas quanto tempo levou.

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 a diferença entre duas marcas de tempo POSIXct. Você pode escolher as unidades: 'secs', 'mins', 'hours', 'days'.

Isso funciona naturalmente com Sys.time() para produzir resultados de cronometragem fáceis 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
')

Cronometragem em um loop com replicate()

Uma única medição de tempo pode variar devido à coleta de lixo ou ao agendamento do sistema operacional. replicate(n, system.time(expr)['elapsed']) executa a expressão várias vezes e retorna um vetor de tempos transcorridos.

Calcular a mediana das medições repetidas fornece uma estimativa mais estável.

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

Comparando duas abordagens

Use system.time() para comparar diretamente duas implementações da mesma tarefa. Esse padrão ajuda a confirmar que uma abordagem é mais rápida antes de adotá-la.

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

Cronometrando operações aninhadas

Você pode aninhar chamadas a system.time() ou usar pontos de verificação com proc.time() dentro de um fluxo de trabalho para identificar qual etapa é o gargalo.

Imprima as variações intermediárias à medida que o script é executado para construir uma linha do tempo do seu 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
')

Dicas práticas para cronometragem

Tenha estas práticas em mente ao cronometrar código R:

Execute o código uma vez antes da medição para aquecer o JIT e os caches de arquivos
Use gc() antes da medição para redefinir o estado da coleta de lixo
Prefira a mediana à média entre as repetições — valores atípicos da coleta de lixo distorcem a média
Cronometre o gargalo, não o script inteiro

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ção rápida: componentes de system.time()

Qual componente de system.time() representa os segundos reais do relógio de parede transcorridos durante a execução?

Recapitulação da cronometragem de desempenho

Agora você dispõe de três ferramentas complementares de cronometragem no R básico:

system.time(expr) — maneira mais rápida de cronometrar uma expressão; retorna user/sys/elapsed
proc.time() — cronometragem baseada em instantâneos para blocos arbitrários de código
Sys.time() + difftime() — marcas de tempo do relógio de parede e intervalos fáceis de interpretar

Use replicate() para obter medições medianas estáveis antes de tirar conclusões sobre o desempenho.

Perguntas Frequentes

A aula “system.time() e proc.time()” é grátis?

Sim — o texto completo de “system.time() e proc.time()” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “system.time() e proc.time()”?

Meça o tempo decorrido, do usuário e do sistema para expressões do R. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “system.time() e proc.time()”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

system.time() e proc.time()
Criação de perfis de código com Rprof e profvis
Vetorização para obter velocidade
Avaliação de desempenho com microbenchmark

← Voltar para R Academy