Ruby Yöntemleri için Ölçme ve Karşılaştırma Süresi

Ruby'de bir yöntem tarafından harcanan zamanı ve bu yöntemdeki bireysel ifadeleri nasıl ölçebilirim? Aşağıdaki yöntemi görürseniz, yöntemin harcadığı toplam süreyi ve veritabanı erişimi ve redis erişimi için harcanan zamanı ölçmek istiyorum. Her ifadeden önce Benchmark.measure yazmak istemiyorum. Ruby tercümanı bunu yapmamız için bize herhangi bir kanca veriyor mu?

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

TimeNesneyi kullanabilirsin . ( Zaman Belgeleri )

Örneğin,

start = Time.now
# code to time
finish = Time.now

diff = finish - start

diff saniye cinsinden kayan nokta sayısı olarak olacaktır.

EDIT: endsaklıdır.

En basit yol:

require 'benchmark'

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

Örnek çıktı:

2.2.3 :001 > foo
  5.230000   0.020000   5.250000 (  5.274806)

Değerler şunlardır: cpu zamanı, sistem zamanı, toplam ve gerçek geçen süre.

Kaynak: ruby docs .

BenchmarkRaporunu Kullan

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

Bu, aşağıdaki gibi bir sonuç verecektir:

                        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.

Daha fazla bilgiyi burada bulabilirsiniz .

Cevapların birçoğu, kullanımını öneriyor Time.now. Ancak Time.nowdeğişebileceğinin farkında olmaya değer . Sistem saatleri kayabilir ve sistem yöneticisi tarafından veya NTP aracılığıyla düzeltilebilir. Bu nedenle Time.now'un ileri veya geri atlaması ve kıyaslamanıza hatalı sonuçlar vermesi mümkündür.

Daha iyi bir çözüm, işletim sisteminin her zaman ilerleyen monoton saatini kullanmaktır. Ruby 2.1 ve üzeri, buna şu yolla erişim sağlar:

start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
# code to time
finish = Process.clock_gettime(Process::CLOCK_MONOTONIC)
diff = finish - start # gets time is seconds as a float

Daha fazla ayrıntıyı buradan okuyabilirsiniz . Ayrıca popüler Ruby projesi Sidekiq'in monoton saate geçiş yaptığını görebilirsiniz .

İkinci bir düşünce, measure () işlevini Ruby kod bloğu argümanı ile tanımlamak , zaman ölçüm kodunu basitleştirmeye yardımcı olabilir:

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

Wquist'in cevabı ruhuna göre , ancak biraz daha basit, aşağıdaki gibi de yapabilirsiniz:

start = Time.now
# code to time
Time.now - start

İçine bak ruby-profpakette, ne gerek olmalıdır. Zamanlamalarla büyük çağrı yığınları oluşturacaktır.

http://ruby-prof.rubyforge.org/

Çok ayrıntılı olabilir, bu durumda daha büyük bölümleri sarmak Benchmark.measureiyi bir yol olabilir.

Ray konsolunda kodu otomatik olarak karşılaştırmanın başka bir yöntemi de bu cevheri kullanmaktır: https://github.com/igorkasyanchuk/execution_time

günlüklerdeki isteklerden aldığınız benzer bilgileri göreceksiniz