Mesurer et comparer le temps pour les méthodes Ruby

Question

Comment puis-je mesurer le temps pris par une méthode et les déclarations individuelles dans cette méthode dans Ruby. Si vous voyez la méthode ci-dessous, je veux mesurer le temps total pris par la méthode et le temps nécessaire à l'accès à la base de données et à l'accès redis. Je ne veux pas écrire Benchmark.measure avant chaque déclaration. Est-ce que l'interpréteur rubis nous donne des crochets pour le faire ?

def foo
# code to access database
# code to access redis. 
end

Answer 1

La manière la plus simple :

require 'benchmark'

def foo
 time = Benchmark.measure {
  code to test
 }
 puts time.real #or save it to logs
end

Échantillon de sortie :

2.2.3 :001 > foo
  5.230000   0.020000   5.250000 (  5.274806)

Les valeurs sont : temps cpu, temps système, temps total et temps réel écoulé.

Source : Ruby docs.

Answer 2

Vous pouvez utiliser l'objet Time. (Time Docs)

Par exemple,

start = Time.now
# => 2022-02-07 13:55:06.82975 +0100
# code to time
finish = Time.now
# => 2022-02-07 13:55:09.163182 +0100
diff = finish - start
# => 2.333432

diff serait en secondes, comme un nombre à virgule flottante.

Answer 3

Utiliser le rapport de Benchmark

require 'benchmark' # Might be necessary.

def foo
  Benchmark.bm( 20 ) do |bm|  # The 20 is the width of the first column in the output.
    bm.report( "Access Database:" ) do 
      # Code to access database.
    end
   
    bm.report( "Access Redis:" ) do
      # Code to access redis.
    end
  end
end

Cela produira quelque chose comme ceci :

                        user     system      total        real
Access Database:    0.020000   0.000000   0.020000 (  0.475375)
Access Redis:       0.000000   0.000000   0.000000 (  0.000037)

<------ 20 -------> # This is where the 20 comes in. NOTE: This is not shown in output.

Vous trouverez plus d'informations ici.

Answer 4

Une seconde réflexion, définir la fonction measure() avec l'argument de bloc de code Ruby peut aider à simplifier le code de mesure du temps :

def measure(&block)
  start = Time.now
  block.call
  Time.now - start
end

# t1 and t2 is the executing time for the code blocks.
t1 = measure { sleep(1) }

t2 = measure do
  sleep(2)
end