0Pricing
R Academy · Leçon

system.time() et proc.time()

Mesurez le temps écoulé, le temps utilisateur et le temps système des expressions R.

system.time() et proc.time() est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Pourquoi mesurer les performances ?

Avant d’optimiser votre code, vous devez le mesurer. Deviner où se trouve la lenteur conduit à des efforts inutiles. R fournit des outils intégrés pour mesurer précisément la durée d’exécution des expressions.

Les trois principaux outils sont system.time(), proc.time() et Sys.time(). Chacun répond à un objectif différent dans l’analyse des performances.

Notions de base sur system.time()

system.time(expr) évalue une expression et renvoie la durée de son exécution. C’est la manière la plus simple de mesurer la durée d’une seule opération dans R.

Le résultat est un objet de la classe proc_time contenant des éléments nommés que vous pouvez examiner.

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

Lire les trois valeurs de durée

system.time() renvoie cinq valeurs, mais trois sont particulièrement importantes :

  • user — temps CPU utilisé directement par le code R
  • sys — temps CPU utilisé par le système d’exploitation pour le compte de R
  • elapsed — temps réel écoulé (secondes effectivement passées)

Le temps écoulé est généralement celui qui vous intéresse. La somme de user et sys peut dépasser elapsed sur les machines multicœurs.

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

proc.time() pour mesurer manuellement

proc.time() renvoie une photographie des temps CPU et écoulé actuels. En l’appelant avant et après un bloc, vous pouvez mesurer la durée de n’importe quelle portion de code.

Soustrayez la photographie de départ de celle de fin pour obtenir le temps écoulé pour cette section.

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

Composants de proc.time()

proc.time() renvoie un vecteur numérique nommé composé de trois éléments :

  • user.self — temps CPU utilisateur du processus R
  • sys.self — temps CPU système du processus R
  • elapsed — temps réel écoulé depuis le démarrage de R

La différence entre deux appels à proc.time() fournit des écarts de durée pertinents.

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

Sys.time() pour les horodatages en temps réel

Sys.time() renvoie la date et l’heure actuelles sous la forme d’un objet POSIXct. Contrairement à proc.time(), il fournit un horodatage réel, et pas seulement l’utilisation du CPU.

C’est utile pour enregistrer quand un événement s’est produit, et pas seulement le temps qu’il a pris.

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

difftime() pour mesurer les intervalles

difftime(end, start, units='secs') calcule la différence entre deux horodatages POSIXct. Vous pouvez choisir les unités : 'secs', 'mins', 'hours', 'days'.

Cette fonction s’associe naturellement à Sys.time() pour obtenir une durée lisible.

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

Mesurer une boucle avec replicate()

Une seule mesure de durée peut varier en raison du ramasse-miettes ou de la planification du système d’exploitation. replicate(n, system.time(expr)['elapsed']) exécute l’expression plusieurs fois et renvoie un vecteur des temps écoulés.

La médiane des mesures répétées fournit une estimation plus stable.

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

Comparer deux approches

Utilisez system.time() pour comparer directement deux implémentations d’une même tâche. Cette méthode vous aide à confirmer qu’une approche est plus rapide avant de l’adopter.

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

Mesurer des opérations imbriquées

Vous pouvez imbriquer des appels à system.time() ou utiliser des points de contrôle proc.time() dans un flux de travail afin d’identifier l’étape qui constitue le goulot d’étranglement.

Affichez les écarts intermédiaires pendant l’exécution du script pour construire une chronologie de votre 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
')

Conseils pratiques pour mesurer les durées

Gardez ces pratiques à l’esprit lorsque vous mesurez du code R :

  • Exécutez le code une fois avant la mesure pour réchauffer le compilateur JIT et les caches de fichiers
  • Utilisez gc() avant la mesure pour réinitialiser l’état du ramasse-miettes
  • Préférez la médiane à la moyenne sur les répétitions — les valeurs aberrantes dues au ramasse-miettes faussent la moyenne
  • Mesurez le goulot d’étranglement, pas le script entier
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
')

Vérification rapide&nbsp;: composants de system.time()

Quel composant de system.time() représente les secondes réelles écoulées pendant l’exécution ?

Récapitulatif de la mesure des performances

Vous disposez maintenant de trois outils complémentaires pour mesurer les durées dans R de base :

  • system.time(expr) — méthode la plus rapide pour mesurer une expression ; renvoie user/sys/elapsed
  • proc.time() — mesure fondée sur des instantanés pour des blocs de code quelconques
  • Sys.time() + difftime() — horodatages en temps réel et intervalles lisibles

Utilisez replicate() pour obtenir des mesures médianes stables avant de tirer des conclusions sur les performances.

Questions Fréquemment Posées

La leçon « system.time() et proc.time() » est-elle gratuite ?

Oui — le texte complet de « system.time() et proc.time() » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « system.time() et proc.time() » ?

Mesurez le temps écoulé, le temps utilisateur et le temps système des expressions R. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « system.time() et proc.time() » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. system.time() et proc.time()
  2. Profiler du code avec Rprof et profvis
  3. Vectorisation pour accélérer le code
  4. Évaluer les performances avec microbenchmark
← Retour à R Academy