Parent

Class/Module Index [+]

Quicksearch

OpenShift::Runtime::Utils::Cgroups::MonitoredGear

Constants

MIN_DELAY

Attributes

gear[R]
thread[RW]
times[RW]

Public Class Methods

delay() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 165
def delay
  @@delay ||= (@@_delay || new_delay)
end
delay=(delay) click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 154
def delay=(delay)
  @@delay = delay
  # Store this explicit delay so that it doesn't get overwritten
  @@_delay = delay
  @@max = nil
end
intervals() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 169
def intervals
  @@intervals
end
intervals=(intervals) click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 148
def intervals=(intervals)
  @@intervals = intervals
  @@delay = nil
  @@max = nil
end
max() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 161
def max
  @@max ||= intervals.max + (delay * 2)
end
new(uuid) click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 55
def initialize(uuid)
  @gear = OpenShift::Runtime::Utils::Cgroups.new(uuid)
  @times = {}
end

Protected Class Methods

new_delay() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 174
def new_delay
  new_delay = intervals.min.to_f / 4
  [new_delay, MIN_DELAY].max
end

Public Instance Methods

age() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 78
def age
  (newest - oldest) rescue 0.0
end
calculate_differences(values) click to toggle source

For each value in the hash, calculate the difference between elements

# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 186
def calculate_differences(values)
  values.inject({}){|h,(k,v)| h[k] = v.each_cons(2).map { |a,b| b-a }; h}
end
collapse_hashes(hashes) click to toggle source

Collapse multiple hashes into a single hash with the values from corresponding keys combined

# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 181
def collapse_hashes(hashes)
  hashes.inject(Hash.new{|h,k| h[k] = []}){|h,vals| vals.each{|k,v| h[k] << v}; h}
end
elapsed_usage(hashes) click to toggle source

Calculate the elapsed usage as a percentage of the max for that time period Doing it this way allows us to calculate the percentage based on the quota and period at the time of each measurement in case it changes

# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 114
def elapsed_usage(hashes)
  # These are keys we don't want to include in our calculations
  util_keys = [:cfs_quota_us, :nr_periods, :cfs_period_us]
  # Collect all of the values into a single hash
  values = collapse_hashes(hashes)
  # Calculate the differences across values
  differences = calculate_differences(values)

  # Disregard the first quota, so we can align with the differences
  (quotas = values[:cfs_quota_us]).shift
  periods = differences[:nr_periods]

  # Find the max utils by multiplying the quotas and number of elapsed periods
  quota_periods = quotas.mult(periods)

  differences.inject({}) do |h,(k,vals)|
    unless util_keys.include?(k) || vals.empty?
      # Calculate the values as a percentage of the max utilization for a period
      percentage = vals.divide(quota_periods)#.mult(100)
      per_period = vals.divide(periods)
      {
        nil          => vals.average,
        "per_period" => per_period.average.round(3),
        "percent"    => percentage.average.round(3),
      }.each do |k2,v|
        key = [k,k2].compact.join('_').to_sym
        h[key] = v
      end
    end
    h
  end
end
newest() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 74
def newest
  times.max.first
end
oldest() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 70
def oldest
  times.min.first
end
update(vals) click to toggle source

Get the current values and remove any expired values Then make sure our intervals are updated

# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 62
def update(vals)
  time = Time.now
  @times[time] = vals
  @utilization = nil
  cutoff = time - MonitoredGear.max
  @times.delete_if{|k,v| k < cutoff }
end
update_utilization() click to toggle source

Update the elapsed intervals

# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 87
def update_utilization
  utilization = {}
  unless times.empty?
    cur = newest
    # Go through each interval we want
    threads = MonitoredGear.intervals.map do |i|
      Thread.new do
        if age.to_i >= i
          # Find any values at or after our cutoff
          vals = times.select{|k,v| k >= (cur - i)}
          # Make sure we have enough sample points for this dataset
          if vals.length > 0
            # Calculate the elapsed usage for our values
            utilization[i] = elapsed_usage(vals.values)
          end
        end
      end
    end
    threads.map(&:join)
  end
  Hash[utilization.sort]
end
utilization() click to toggle source
# File lib/openshift-origin-node/utils/cgroups/monitored_gear.rb, line 82
def utilization
  @utilization ||= update_utilization
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.