0Pricing
Ruby Academy · Leçon

Mesurer les performances

Module Benchmark

Mesurer les performances est une leçon Ruby 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 Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Pourquoi mesurer ?

Optimiser sans mesurer, c’est deviner. Le module Benchmark de la bibliothèque standard de Ruby mesure précisément la durée d’exécution du code.

  • Repérez les parties lentes avant de les modifier
  • Comparez objectivement les implémentations
  • Évitez l’optimisation prématurée
require 'benchmark'

time = Benchmark.realtime do
  1_000_000.times { |i| i * 2 }
end
puts "Took #{time.round(4)}s"

Benchmark.measure

Benchmark.measure renvoie un rapport sur les temps utilisateur, système et réel.

  • Le temps utilisateur correspond au temps CPU consacré à votre code
  • Le temps réel correspond au temps écoulé selon l’horloge
require 'benchmark'

result = Benchmark.measure do
  500_000.times { |i| i.to_s }
end
puts result

Benchmark.bm

Benchmark.bm exécute plusieurs blocs et les étiquette dans un tableau.

  • Indiquez une largeur d’étiquette pour l’alignement
  • Chaque x.report constitue une ligne
require 'benchmark'

Benchmark.bm(10) do |x|
  x.report('to_s:') { 100_000.times { |i| i.to_s } }
  x.report('inspect:') { 100_000.times { |i| i.inspect } }
end

Benchmark.bmbm

Benchmark.bmbm effectue d’abord une répétition pour réchauffer les caches et le GC, ce qui fournit des chiffres plus fiables.

  • Le premier passage est ignoré
  • Le deuxième passage constitue la mesure réelle
require 'benchmark'

Benchmark.bmbm do |x|
  x.report('sum:') { (1..100_000).sum }
  x.report('reduce:') { (1..100_000).reduce(:+) }
end

realtime pour un chronométrage rapide

Benchmark.realtime renvoie uniquement les secondes écoulées selon l’horloge, sous forme de nombre à virgule.

  • La manière la plus simple de chronométrer un bloc
  • Pratique pour les vérifications ponctuelles
require 'benchmark'

elapsed = Benchmark.realtime do
  arr = Array.new(100_000) { rand }
  arr.sort
end
puts "Sorted in #{elapsed.round(4)}s"

Horloge monotone

Pour mesurer précisément sans être affecté par les changements de l’horloge système, utilisez Process.clock_gettime avec une horloge monotone.

  • Insensible aux ajustements de NTP
  • L’option intégrée la plus précise
start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
200_000.times { |i| i * i }
finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
puts "Elapsed: #{(finish - start).round(4)}s"

Comparer deux approches

Les évaluations de performance sont particulièrement utiles pour comparer des solutions. Exécutez-les toutes les deux sous une charge identique.

  • La taille des données d’entrée doit être suffisamment grande pour être mesurable
  • Répétez les mesures pour réduire le bruit
require 'benchmark'

arr = (1..100_000).to_a
Benchmark.bm(8) do |x|
  x.report('map:') { arr.map { |n| n * 2 } }
  x.report('each:') { r = []; arr.each { |n| r << n * 2 } }
end

Attention aux micro-évaluations de performance

De très petites évaluations de performance peuvent induire en erreur.

  • Le JIT et les caches peuvent ne pas refléter les charges de travail réelles
  • Le GC peut se déclencher au milieu de la mesure
  • Mesurez des tailles de données réalistes
require 'benchmark'

# Too small to be meaningful
t = Benchmark.realtime { 10.times { |i| i + 1 } }
puts "Misleadingly tiny: #{t}s"

Itérations par seconde

Vous cherchez souvent le débit : le nombre d’opérations par seconde. Le paquet benchmark-ips le fournit, mais vous pouvez aussi l’estimer manuellement.

  • Comptez les itérations pendant une durée fixe
  • Plus ips est élevé, plus l’exécution est rapide
deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 0.2
count = 0
while Process.clock_gettime(Process::CLOCK_MONOTONIC) < deadline
  count += 1
  'hello'.upcase
end
puts "Iterations in 0.2s: #{count}"

Contrôler le ramasse-miettes

Le ramasse-miettes peut fausser les résultats. Vous pouvez le désactiver temporairement pour obtenir des chiffres plus stables.

  • GC.disable avant, GC.enable après
  • Utilisez cette technique avec prudence pour éviter une croissance de la mémoire
require 'benchmark'

GC.disable
t = Benchmark.realtime { 100_000.times { |i| i.to_s } }
GC.enable
puts "Without GC: #{t.round(4)}s"

Faire la moyenne de plusieurs exécutions

Exécutez une évaluation de performance plusieurs fois et calculez la moyenne pour atténuer les variations.

  • Écartez la valeur aberrante la plus lente si nécessaire
  • Indiquez la médiane pour plus de stabilité
require 'benchmark'

times = 3.times.map do
  Benchmark.realtime { (1..50_000).map { |n| n * n } }
end
avg = times.sum / times.size
puts "Average: #{avg.round(4)}s"

Vérification rapide

Vérifiez vos connaissances en matière d’évaluation de performance.

Récapitulatif

Vous avez appris à mesurer les performances :

  • Le module Benchmark mesure précisément la durée d’exécution du code
  • realtime, measure, bm et bmbm répondent à des besoins différents
  • Utilisez l’horloge monotone pour mesurer avec précision
  • Évitez les micro-évaluations trompeuses et tenez compte du GC
  • Calculez la moyenne de plusieurs exécutions pour réduire le bruit

Ensuite, vous utiliserez des outils de profilage dédiés.

Questions Fréquemment Posées

La leçon « Mesurer les performances » est-elle gratuite ?

Oui — le texte complet de « Mesurer les performances » 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 Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mesurer les performances » ?

Module Benchmark Tu pratiques Ruby 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 Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby 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 « Mesurer les performances » ?

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 Ruby Academy ?

Oui. Chaque leçon Ruby 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. Mesurer les performances
  2. Outils de profilage
  3. Optimisation de la mémoire
  4. Goulots d’étranglement courants
← Retour à Ruby Academy