new(bc_method)
click to toggle source
Returns a Clock instance for CaseMethod instance bc_method.
def initialize(bc_method)
@bc_method = bc_method
@times = Hash.new { |h, k| h[k] = [] }
@repeat = 0
@scatter = 0
end
repeat(bc_method)
click to toggle source
Use a Clock instance to measure the time necessary
to do bc_method.case.iterations repetitions of bc_method.
def self.repeat(bc_method)
clock = new(bc_method)
bs = clock.case.batch_size.abs
bs = 1 if !bs or bs < 0
clock.case.iterations.times do
bc_method.before_run
$DEBUG and warn "Calling #{bc_method.name}."
clock.inc_scatter
clock.measure do
bs.times { yield }
end
bc_method.after_run
end
clock
end
scale_range(bc_method)
click to toggle source
Iterate over the range of the RangeCase instance of this bc_method and take measurements
(including scattering).
def self.scale_range(bc_method)
clock = new(bc_method)
my_case = clock.case
bs = my_case.batch_size.abs
bs = 1 if !bs or bs < 0
for a in my_case.range
begin
my_case.args = (a.dup rescue a).freeze
clock.inc_scatter
my_case.scatter.times do
bc_method.before_run
$DEBUG and warn "Calling #{bc_method.name}."
clock.measure do
bs.times { yield }
end
bc_method.after_run
end
ensure
my_case.args = nil
end
end
clock
end
time(bc_method)
click to toggle source
Use a Clock instance to measure how many
repetitions of bc_method can be
done in bc_method.case.duration seconds (a float value). If the
bc_method.case.batch_size is >1 duration is multiplied by batch_size
because the measured times are averaged by batch_size.
def self.time(bc_method)
clock = new(bc_method)
duration = clock.case.duration.abs
if bs = clock.case.batch_size and bs > 1
duration *= bs
end
until_at = Time.now + duration
bs = clock.case.batch_size.abs
bs = 1 if !bs or bs < 0
begin
bc_method.before_run
$DEBUG and warn "Calling #{bc_method.name}."
clock.inc_scatter
clock.measure do
bs.times { yield }
end
bc_method.after_run
end until clock.time > until_at
clock
end
times()
click to toggle source
The times which should be displayed in the output.
def self.times
TIMES.map { |t| t.to_s }
end
to_a()
click to toggle source
Return column names in relation to Clock#to_a method.
def self.to_a
%w[ #scatter ] + TIMES + %w[ repeat ]
end
<<(times)
click to toggle source
Add the array times to this clock’s time measurements.
times consists of the time measurements in float values in order
of TIMES.
def <<(times)
r = times.shift
@repeat += 1 if @times[:repeat].last != r
@times[:repeat] << r
TIMES.zip(times) { |t, time| @times[t] << time.to_f }
self
end
analysis()
click to toggle source
Returns a Hash of Analysis object for all of
TIMES’s time keys.
def analysis
@analysis ||= Hash.new do |h, time|
time = time.to_sym
times = @times[time]
h[time] = Analysis.new(times)
end
end
arithmetic_mean(time)
click to toggle source
Returns the arithmetic mean of time.
def arithmetic_mean(time)
analysis[time.to_sym].mean
end
autocorrelation(time)
click to toggle source
Return the array of autocorrelation values for time.
def autocorrelation(time)
analysis[time.to_sym].autocorrelation
end
autocorrelation_plot(time)
click to toggle source
Returns the arrays for the autocorrelation plot, the first array for the
numbers of lag measured, the second for the autocorrelation value.
def autocorrelation_plot(time)
r = autocorrelation time
start = @times[:repeat].first
ende = (start + r.size)
(start...ende).to_a.zip(r)
end
call_time_mean()
click to toggle source
Seconds per call (mean)
def call_time_mean
mean(self.case.compare_time)
end
calls(call_time_type)
click to toggle source
Calls per second of the call_time_type, e. g. :call_time_mean or :call_time_median.
def calls(call_time_type)
__send__(call_time_type) ** -1
end
calls_mean()
click to toggle source
Calls per second (mean)
def calls_mean
call_time_mean ** -1
end
case()
click to toggle source
The benchmark case class this clock belongs to (via bc_method).
def case
@bc_method.case.class
end
cover?(other)
click to toggle source
Return true, if other’s mean value is indistinguishable from this
object’s mean after filtering out the noise from the measurements
with a Welch’s t-Test. This mean’s that differences in the mean
of both clocks might not inidicate a real performance difference and may be
caused by chance.
def cover?(other)
time = self.case.compare_time.to_sym
analysis[time].cover?(other.analysis[time], self.case.covering.alpha_level.abs)
end
detect_autocorrelation(time)
click to toggle source
Returns the q value for the Ljung-Box statistic of this
time’s analysis.detect_autocorrelation method.
def detect_autocorrelation(time)
analysis[time.to_sym].detect_autocorrelation(
self.case.autocorrelation.max_lags.to_i,
self.case.autocorrelation.alpha_level.abs)
end
detect_outliers(time)
click to toggle source
Return a result hash with the number of :very_low, :low, :high, and
:very_high outliers, determined by the box plotting algorithm run with
:median and :iqr parameters. If no outliers were found or the iqr is less
than epsilon, nil is returned.
def detect_outliers(time)
analysis[time.to_sym].detect_outliers(self.case.outliers_factor.abs)
end
file_path(*args)
click to toggle source
Return the result of CaseMethod#file_path for this
clock’s bc_method.
def file_path(*args)
@bc_method.file_path(*args)
end
find_truncation_offset()
click to toggle source
Find an offset from the start of the measurements in this clock to truncate
the initial data until a stable state has been reached and return it as an
integer.
def find_truncation_offset
truncation = self.case.truncate_data
slope_angle = self.case.truncate_data.slope_angle.abs
time = self.case.compare_time.to_sym
ms = analysis[time].measurements.reverse
offset = ms.size - 1
@slopes = []
ModuleFunctions.array_window(ms, truncation.window_size) do |data|
lr = LinearRegression.new(data)
a = lr.a
@slopes << [ offset, a ]
a.abs > slope_angle and break
offset -= 1
end
offset < 0 ? 0 : offset
end
geometric_mean(time)
click to toggle source
Returns the geometric mean of time.
def geometric_mean(time)
analysis[time.to_sym].geometric_mean
end
harmonic_mean(time)
click to toggle source
Returns the harmonic mean of time.
def harmonic_mean(time)
analysis[time.to_sym].harmonic_mean
end
histogram(time)
click to toggle source
Return the Histogram for the time
values.
def histogram(time)
analysis[time.to_sym].histogram(self.case.histogram.bins)
end
inc_scatter()
click to toggle source
Increment scatter counter by one.
def inc_scatter
@scatter += 1
end
max(time)
click to toggle source
Returns the maximum for the time (one of TIMES’ symbols).
def max(time)
analysis[time.to_sym].max
end
mean(time)
click to toggle source
measure()
click to toggle source
Take a single measurement. This method should be called with the code to
benchmark in a block.
def measure
before = take_time
yield
after = take_time
@repeat += 1
@times[:repeat] << @repeat
@times[:scatter] << @scatter
bs = self.case.batch_size.abs
if bs and bs > 1
TIMES.each_with_index { |t, i| @times[t] << (after[i] - before[i]) / bs }
else
TIMES.each_with_index { |t, i| @times[t] << after[i] - before[i] }
end
@analysis = nil
end
min(time)
click to toggle source
Returns the minimum for the time (one of TIMES’ symbols).
def min(time)
analysis[time.to_sym].min
end
percentile(time, p = 50)
click to toggle source
Returns the p-percentile of the time values (one of
TIMES’ symbols).
def percentile(time, p = 50)
analysis[time.to_sym].percentile p
end
sample_standard_deviation(time)
click to toggle source
Returns the sample standard deviation for the time (one of
TIMES’ symbols).
def sample_standard_deviation(time)
analysis[time.to_sym].sample_standard_deviation
end
sample_standard_deviation_percentage(time)
click to toggle source
Returns the sample standard deviation for the time (one of
TIMES’ symbols) in percentage of its arithmetic mean.
def sample_standard_deviation_percentage(time)
analysis[time.to_sym].sample_standard_deviation_percentage
end
sum(time)
click to toggle source
Returns the sum of measurement times for time.
def sum(time)
__send__ time
end
take_time()
click to toggle source
Takes the times an returns an array, consisting of the times in the order
of enumerated in the TIMES constant.
def take_time
@time, times = Time.now, Process.times
user_time = times.utime + times.cutime
system_time = times.stime + times.cstime
total_time = user_time + system_time
[ @time.to_f, total_time, user_time, system_time ]
end
to_a()
click to toggle source
Returns the measurements as an array of arrays.
def to_a
if @repeat >= 1
(::Bullshit::Clock::ALL_COLUMNS).map do |t|
analysis[t].measurements
end.transpose
else
[]
end
end
truncate_data(offset)
click to toggle source
Truncate the measurements stored in this clock starting from the integer
offset.
def truncate_data(offset)
for t in ALL_COLUMNS
times = @times[t]
@times[t] = @times[t][offset, times.size]
@repeat = @times[t].size
end
@analysis = nil
self
end
![[+]](../images/find.png "show/hide quicksearch")