cpu 0.0.0

data/Gemfile

@@ -0,0 +1,13 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source :rubygems
+
+gemspec
+
+group :development do
+  gem 'rake', '~>0.9.2'
+  gem 'sdoc', '~>0.2.20'
+  gem 'rcov', '~>0.9.9'
+  gem 'test-unit', '~>2.3.0'
+  gem 'mocha', '~>0.9.12'
+end

data/Rakefile

@@ -0,0 +1,121 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+begin
+  require 'rubygems/package_task'
+rescue LoadError
+end
+begin
+  require 'rcov/rcovtask'
+rescue LoadError
+end
+require 'rake/clean'
+require 'rake/testtask'
+require 'rbconfig'
+include Config
+
+PKG_NAME    = 'cpu'
+PKG_VERSION = File.read('VERSION').chomp
+PKG_FILES   = FileList[*`git ls-files`.split(/\n/)].exclude '.gitignore'
+CLEAN.include 'coverage', 'doc'
+CLOBBER.include 'pkg'
+
+desc "Install executable/library into site_ruby directories"
+task :install  do
+  bindir = CONFIG['bindir']
+  libdir = CONFIG['sitelibdir']
+  cd 'lib' do
+    for file in Dir['**/*.rb']
+      dest = File.join(libdir, file)
+      mkdir_p File.dirname(dest)
+      install file, dest, :verbose => true
+    end
+  end
+  install('bin/coretemp', bindir, :verbose => true, :mode => 0755)
+end
+
+desc "Create documentation"
+task :doc do
+  sh "sdoc -m README.rdoc -t 'CPU' README.rdoc #{Dir['lib/**/*.rb'] * ' '}"
+end
+
+namespace :gems do
+  desc "Install all gems from the Gemfile"
+  task :install  do
+    sh 'bundle install'
+  end
+end
+
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary = "CPU information in Ruby/Linux"
+    s.description = "Library to gather CPU information (load averages, usage,"\
+      " temperature) in Ruby on Linux"
+
+    s.executables = 'coretemp'
+    s.files = PKG_FILES
+
+    s.require_path = 'lib'
+
+    s.add_dependency 'spruz', '~>0.2.2'
+
+    s.rdoc_options << '--main' <<  'README.rdoc' << '--title' << 'CPU'
+    s.extra_rdoc_files << 'README.rdoc'
+    s.test_files.concat Dir['tests/test_*.rb']
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://flori.github.com/#{PKG_NAME}"
+    s.rubyforge_project = PKG_NAME
+  end
+
+  desc 'Create a gemspec file'
+  task :gemspec => :version do
+    File.open('cpu.gemspec', 'w') do |gemspec|
+      gemspec.write spec.to_ruby
+    end
+  end
+
+  Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+    pkg.package_files += PKG_FILES
+  end
+end
+
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['tests/**/*_test.rb']
+  t.verbose    = true
+end
+
+if defined? Rcov
+  Rcov::RcovTask.new do |t|
+    t.test_files = FileList['tests/**/*_test.rb']
+    t.verbose    = true
+    t.rcov_opts = %w[-x '\\btests\/' -x '\\bgems\/']
+  end
+end
+
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', 'cpu', 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+module CPU
+  # CPU version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end
+EOT
+  end
+end
+
+desc "Run the tests by default"
+task :default => [ :version, :test ]
+
+desc "Prepare release of the library"
+task :release => [ :clean, :gemspec, :package ]

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/coretemp

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'cpu'
+require 'spruz/go'
+include Spruz::GO
+require 'bullshit'
+
+class ParseCommands
+  def self.parse(argv)
+    new(argv).parse
+  end
+
+  def initialize(argv)
+    @argv = argv
+  end
+
+  def set_t_j_max(temp)
+    t_j_max = temp and CPU.t_j_max = t_j_max.to_i
+  end
+
+  def create_history_path(filename)
+    filename ||= '~/.coretemp-history'
+    File.expand_path(filename)
+  end
+
+  def measure_temps(opts)
+    set_t_j_max opts['t']
+    CPU.each_core.map(&:temperature)
+  end
+
+  def simple
+    opts = go 't', @argv
+    puts measure_temps(opts) * ' '
+  end
+
+  def collect
+    opts = go 'tf', @argv
+    filename = create_history_path opts['f']
+    temperatures = measure_temps(opts)
+    line = ([ Time.now.to_f ] + temperatures) * ' '
+    if filename
+      open(filename, 'a') do |o|
+        o.puts line
+      end
+    end
+  end
+
+  def clear
+    opts = go 'f', @argv
+    filename = create_history_path opts['f']
+    if filename and File.exist?(filename)
+      File.unlink(filename)
+    end
+  end
+
+  def stats
+    opts = go 'f', @argv
+    filename = create_history_path opts['f']
+    if filename and File.exist?(filename)
+      history = open(filename, 'r') { |o|
+        o.map do |line|
+          time, *temps = line.split(/\s+/)
+          [ Time.at(Float(time)) ] + temps.map { |t| Integer(t) }
+        end
+      }
+      measurements_last = history.last[1..-1]
+      times, *measurements = history.transpose
+      analyses = measurements.map { |m| Bullshit::Analysis.new(m) }
+      puts " min: %s" % (analyses.map { |a| a.min  } * ' ')
+      puts "last: %s" % (measurements_last * ' ')
+      puts " max: %s" % (analyses.map { |a| a.max  } * ' ')
+      puts "mean: %s" % (analyses.map { |a| a.mean.round } * ' ')
+    end
+  end
+
+  def parse
+    case command = @argv.shift
+    when 'collect'       then collect
+    when 'clear'         then clear
+    when 'stats'         then stats
+    when 'collect_stats' then collect; stats
+    else                      simple
+    end
+  end
+end
+
+ParseCommands.parse(ARGV)

data/cpu.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cpu}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Florian Frank}]
+  s.date = %q{2011-07-03}
+  s.description = %q{Library to gather CPU information (load averages, usage, temperature) in Ruby on Linux}
+  s.email = %q{flori@ping.de}
+  s.executables = [%q{coretemp}]
+  s.extra_rdoc_files = [%q{README.rdoc}]
+  s.files = [%q{Gemfile}, %q{README.rdoc}, %q{Rakefile}, %q{VERSION}, %q{bin/coretemp}, %q{cpu.gemspec}, %q{lib/cpu.rb}, %q{lib/cpu/load.rb}, %q{lib/cpu/msr.rb}, %q{lib/cpu/processor.rb}, %q{lib/cpu/shared.rb}, %q{lib/cpu/usage.rb}, %q{lib/cpu/usage_sampler.rb}, %q{lib/cpu/version.rb}, %q{munin/coretemp}, %q{tests/load_test.rb}, %q{tests/msr_test.rb}, %q{tests/usage_test.rb}]
+  s.homepage = %q{http://flori.github.com/cpu}
+  s.rdoc_options = [%q{--main}, %q{README.rdoc}, %q{--title}, %q{CPU}]
+  s.require_paths = [%q{lib}]
+  s.rubyforge_project = %q{cpu}
+  s.rubygems_version = %q{1.8.5}
+  s.summary = %q{CPU information in Ruby/Linux}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<spruz>, ["~> 0.2.2"])
+    else
+      s.add_dependency(%q<spruz>, ["~> 0.2.2"])
+    end
+  else
+    s.add_dependency(%q<spruz>, ["~> 0.2.2"])
+  end
+end

data/lib/cpu.rb

@@ -0,0 +1,121 @@
+require 'spruz/uniq_by'
+require 'cpu/shared'
+require 'cpu/processor'
+require 'cpu/msr'
+require 'cpu/load'
+require 'cpu/usage_sampler'
+require 'cpu/usage'
+
+# This module provides (read) access to the Model Specific Registers of Intel
+# CPUs on Linux.
+module CPU
+  class << self
+    # The t_j_max temperature of that is used as a default for this Processor
+    # if it cannot be queried (e.g. Core2 architecture). It defaults to 95
+    # which is the correct value for Core2 Duo E8400 (Wolfsdale). Be sure to
+    # set the correct value for your Core2 CPU here, otherwise your
+    # temperature measurements will be incorrect.
+    attr_accessor :t_j_max
+  end
+  self.t_j_max = 95
+
+  # XXX
+  class CPUError < StandardError; end
+
+  # This exception is thrown if an invalid ProcessorId is queried.
+  class InvalidProcessorIdError < CPUError; end
+
+  # XXX
+  class NoSampleDataError < CPUError; end
+
+  class << self
+    # The path to the modprobe binary which is used to load the required module
+    # if necessary.
+    attr_accessor :modprobe_path
+  end
+  self.modprobe_path = '/sbin/modprobe'
+
+  class << self
+    # Return an array of all Processor instances for this machine.
+    def processors
+      cpu_cores = {}
+      cpuinfos = File.read('/proc/cpuinfo').chomp.split(/^$/)
+      processor_ids =
+        cpuinfos.map { |l| l[/processor\s*:\s*(\d+)/, 1].to_i rescue nil }
+      core_ids = cpuinfos.map { |l| l[/core id\s*:\s*(\d+)/, 1].to_i rescue nil }
+      processor_ids.zip(core_ids) do |processor_id, core_id|
+        cpu_cores[processor_id] = core_id
+      end
+      processors = Dir.open('/dev/cpu').inject([]) do |ps, processor_id|
+        processor_id =~ /\A\d+\Z/ or next ps
+        ps << processor_id.to_i
+      end
+      processors.extend Spruz::UniqBy
+      processors.sort!
+      @num_processors = processors.size
+      @num_cores      = cpu_cores.invert.size
+      processors.map! do |processor_id|
+        Processor.new(processor_id, cpu_cores[processor_id])
+      end
+    end
+
+    def num_processors
+      @num_processors or processors
+      @num_processors
+    end
+
+    def num_cores
+      @num_cores or processors
+      @num_cores
+    end
+
+    alias to_a processors
+
+    def each_core(&block)
+      processors.uniq_by(&:core_id).each(&block)
+    end
+
+    def cores
+      each_core.to_a
+    end
+
+    # Iterate over each Processor instance for this machine and yield to the
+    # block for each of them.
+    def each_processor(&block)
+      processors.each(&block)
+    end
+
+    alias each each_processor
+
+    include Enumerable
+
+    def load
+      Load.new
+    end
+
+    def usage(interval = 1)
+      before_usage = UsageSampler.new
+      if block_given?
+        yield
+      else
+        sleep interval
+      end
+      after_usage = UsageSampler.new
+      processors.each do |processor|
+        processor.usage = after_usage.usages[processor.processor_id] -
+          before_usage.usages[processor.processor_id]
+      end
+    end
+
+    def sum_usage_processor(interval = 1)
+      processors = usage(interval)
+      processor = Processor.new -1, -1
+      processor.num_processors = processor.num_cores = 1
+      processor.temperature = processors.map(&:temperature).max
+      processor.usage = processors.map(&:usage).inject { |s, u| s + u }
+      processor.usage.num_processors = processor.usage.num_cores = 1
+      processor.freeze
+      processor
+    end
+  end
+end

data/lib/cpu/load.rb

@@ -0,0 +1,57 @@
+module CPU
+  class Load
+    include Shared
+
+    def initialize
+      @load_data = File.open('/proc/loadavg') do |loadavg|
+        loadavg.readline.split(/\s+/).first(3).map(&:to_f)
+      end
+    end
+
+    def last_minute
+      @load_data[0]
+    end
+
+    def last_minute_by_core
+      last_minute / num_cores
+    end
+
+    def last_minute_by_processor
+      last_minute / num_processors
+    end
+
+    def last_5_minutes
+      @load_data[1]
+    end
+
+    def last_5_minutes_by_core
+      last_5_minutes / num_cores
+    end
+
+    def last_5_minutes_by_processor
+      last_5_minutes / num_processors
+    end
+
+    def last_15_minutes
+      @load_data[2]
+    end
+
+    def last_15_minutes_by_core
+      last_15_minutes / num_cores
+    end
+
+    def last_15_minutes_by_processor
+      last_15_minutes / num_processors
+    end
+
+    def to_a
+      @load_data.dup
+    end
+
+    def inspect
+      "#<#{self.class}: #{to_a * ' '}>"
+    end
+
+    alias to_s inspect
+  end
+end

data/lib/cpu/msr.rb

@@ -0,0 +1,31 @@
+module CPU
+  class MSR
+    # Returns true if the msr functionality is already available in the kernel
+    # (either compiled into it or via a module).
+    def self.available?
+      File.exist?('/dev/cpu/0/msr')
+    end
+
+    # Loads the msr module and sleeps for a second afterwards.
+    def self.load_module
+      system "#{CPU.modprobe_path} msr"
+      sleep 1
+    end
+
+    def initialize(processor_id)
+      self.class.available? or self.class.load_module
+      begin
+        @io = IO.new IO.sysopen('/dev/cpu/%d/msr' % processor_id, 'rb')
+      rescue Errno::ENOENT
+        raise InvalidProcessorIdError, "'#{processor_id}' is not a valid processor_id on this machine"
+      end
+    end
+
+    # Returns the byte at +offset+ as an integer number.
+    def [](offset)
+      @io.sysseek(offset)
+      data, = @io.sysread(8).unpack('q')
+      data
+    end
+  end
+end

data/lib/cpu/processor.rb

@@ -0,0 +1,72 @@
+module CPU
+  class Processor
+    include Shared
+
+    # Returns a Processor instance for Processor +processor_id+. If this
+    # Processor doesn't exist an InvalidProcessorIdError exception is thrown.
+    def initialize(processor_id, core_id = nil)
+      @processor_id, @core_id = processor_id, core_id
+    end
+
+    # Returns the processor_id of this Processor, an integer in (0..(n - 1))
+    # for a n-core machine.
+    attr_reader :processor_id
+
+    # Returns the core_id of this Processor.
+    attr_reader :core_id
+
+    # Returns an msr object and caches it.
+    def msr
+      @msr ||= MSR.new(processor_id)
+    end
+
+    attr_writer :usage
+
+    def usage(interval = 1)
+      unless @usage
+        if processor = CPU.usage(interval).find { |p| p.processor_id == processor_id }
+          @usage = processor.usage
+        end
+      end
+      @usage
+    end
+
+    # Returns the distance between the core temperature of this Processor and
+    # its t_j_max temperature as an integer number.
+    def t_j_max_distance
+      (msr[0x19c] >> 16) & 0x7f
+    end
+
+    # This method returns the t_j_max temperature of this Processor if the
+    # processor supports it (e. g. Intel i7 architecture) as an integer number,
+    # otherwise 0 is returned.
+    def t_j_max
+      (msr[0x1a2] >> 16) & 0x7f
+    end
+
+    # Returns the core temperature of this Processor as an integer number. This
+    # should work on all Core2 architecures if you set CPU.t_j_max
+    # to the correct value for your Processor. On i7 architectures (and newer?)
+    # it should work without any further configuration.
+    def temperature
+      if @temperature
+        @temperature
+      else
+        my_t_j_max = t_j_max.nonzero? || CPU.t_j_max
+        my_t_j_max - t_j_max_distance
+      end
+    end
+
+    attr_writer :temperature
+
+    def inspect
+      if processor_id >= 0
+        result = "#<#{self.class}: #@processor_id"
+        result << " (core#@core_id)" if @core_id
+        result << '>'
+      else
+        "#<#{self.class}: total>"
+      end
+    end
+  end
+end

data/lib/cpu/shared.rb

@@ -0,0 +1,25 @@
+module CPU
+  module Shared
+    # Returns the number of processors in this computer
+    def num_processors
+      if @num_processors
+        @num_processors
+      else
+        CPU.num_processors
+      end
+    end
+
+    attr_writer :num_processors
+
+    # Returns the number of cores in this computer
+    def num_cores
+      if @num_cores
+        @num_cores
+      else
+        CPU.num_cores
+      end
+    end
+
+    attr_writer :num_cores
+  end
+end

data/lib/cpu/usage.rb

@@ -0,0 +1,65 @@
+module CPU
+  class Usage < Struct.new('Usage', :usage, :processor_id, :user, :nice,
+                           :system, :idle, :start_at, :stop_at)
+    include Shared
+
+    def +(other)
+      self.class.new(*(
+        [
+          usage,
+          processor_id == other.processor_id ? processor_id : 0,
+        ] +
+        values_at(2..-3).zip(other.values_at(2..-3)).map { |x, y| x + y } +
+        [
+          [ start_at, other.start_at ].min,
+          [ stop_at, other.stop_at ].max
+        ])
+      )
+    end
+
+    def -(other)
+      self + other * -1
+    end
+
+    def *(scalar)
+      scalar = scalar.to_f
+      self.class.new(*(
+        [
+          usage,
+          processor_id,
+        ] +
+        values_at(2..-3).map { |x| x * scalar } +
+        [
+          start_at,
+          stop_at,
+        ])
+      )
+    end
+
+    def /(scalar)
+      self * (1.0 / scalar)
+    end
+
+    def process_time
+      user + nice + system
+    end
+
+    def real_time
+      stop_at - start_at
+    end
+
+    def total_time
+      values_at(2..-3).inject(0.0) { |s,  x| s + x }
+    end
+
+    def percentage(time = total_time)
+      100.0 * process_time / time
+    end
+
+    def inspect
+      "#<#{self.class}: #{percentage}>"
+    end
+
+    alias to_s inspect
+  end
+end

data/lib/cpu/usage_sampler.rb

@@ -0,0 +1,40 @@
+module CPU
+  class UsageSampler
+    def initialize
+      sample
+    end
+
+    attr_reader :usages
+
+    def sum_usages
+      @usages and @usages.values.inject(&:+)
+    end
+
+    CPU = /^cpu(\d+)#{'\s+(\d+)' * 4}/
+
+    USER_HZ = 100
+
+    def sample
+      total, @usages = nil, {}
+      timestamp = Time.now
+      File.foreach('/proc/stat') do |line|
+        case line
+        when /^cpu[^\d]/
+          next
+        when CPU
+          times = $~.captures
+          processor_id = times[0] = times[0].to_i
+          (1...times.size).each { |i| times[i] = times[i].to_f / USER_HZ }
+          times << timestamp << timestamp
+          @usages[processor_id] = Usage.new(self, *times)
+        else
+          break
+        end
+      end
+      if @usages.empty?
+        raise NoSampleDataError, "could not sample measurement data"
+      end
+      self
+    end
+  end
+end

data/lib/cpu/version.rb

@@ -0,0 +1,8 @@
+module CPU
+  # CPU version
+  VERSION         = '0.0.0'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/munin/coretemp

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'cpu'
+
+if t_j_max = ENV['t_j_max']
+  CPU.t_j_max = t_j_max.to_i
+end
+
+case ARGV.shift
+when 'config'
+  puts <<EOT
+graph_title CPU Core temperatures
+graph_args --base 1000 -l 0
+graph_vtitle Celsius
+graph_category sensors
+EOT
+  for c in CPU.cores
+    puts "core#{c.core_id}.label Core #{c.core_id}"
+  end
+else
+  for c in CPU.cores
+    puts "core#{c.core_id}.value #{c.temperature}"
+  end
+end

data/tests/load_test.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'mocha'
+require 'cpu'
+
+module CPU
+  class LoadTest < Test::Unit::TestCase
+    def test_load_minutes
+      @load = CPU.load
+      @load.stubs(:num_processors).returns(4)
+      @load.stubs(:num_cores).returns(2)
+      for v in %w[last_minute last_5_minutes last_15_minutes]
+        assert_kind_of Float, @load.__send__(v)
+        assert_operator @load.__send__(v), :>=, 0
+        assert_in_delta\
+          4 * @load.__send__("#{v}_by_processor"),
+          @load.__send__(v),
+          1E-3
+        assert_in_delta\
+          2 * @load.__send__("#{v}_by_core"),
+          @load.__send__(v),
+          1E-3
+      end
+    end
+
+    def test_load_array
+      load_array = CPU.load.to_a
+      assert_equal 3, load_array.size
+      for v in load_array
+        assert_kind_of Float, v
+        assert_operator v, :>=, 0
+      end
+    end
+  end
+end
+

data/tests/msr_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'cpu'
+
+module CPU
+  class MSRTest < Test::Unit::TestCase
+    def setup
+      @cpu0, @cpu1 = CPU.to_a
+    end
+
+    def test_loaded
+      assert CPU::MSR.available?
+    end
+
+    def test_instance
+      assert_kind_of CPU::Processor, @cpu0
+      assert_equal 0, @cpu0.processor_id
+      assert_kind_of CPU::Processor, @cpu1
+      assert_equal 1, @cpu1.processor_id
+    end
+
+    def test_temperature
+      assert_operator @cpu0.temperature, '>', 0
+      assert_operator @cpu1.temperature, '>', 0
+    end
+
+    def test_wrong_processor_id
+      assert_raise(InvalidProcessorIdError) do
+        CPU::MSR.new(CPU.num_processors)
+      end
+    end
+  end
+end

data/tests/usage_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'mocha'
+require 'cpu'
+
+module CPU
+  class UsageTest < Test::Unit::TestCase
+    def test_sum_usage
+      @processor = CPU.sum_usage 0.1
+      assert_kind_of Processor, @processor
+      assert_operator @processor.usage.percentage, :>, 0
+    end
+  end
+end
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: cpu
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Florian Frank
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: spruz
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.2
+  type: :runtime
+  version_requirements: *id001
+description: Library to gather CPU information (load averages, usage, temperature) in Ruby on Linux
+email: flori@ping.de
+executables: 
+- coretemp
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Gemfile
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/coretemp
+- cpu.gemspec
+- lib/cpu.rb
+- lib/cpu/load.rb
+- lib/cpu/msr.rb
+- lib/cpu/processor.rb
+- lib/cpu/shared.rb
+- lib/cpu/usage.rb
+- lib/cpu/usage_sampler.rb
+- lib/cpu/version.rb
+- munin/coretemp
+- tests/load_test.rb
+- tests/msr_test.rb
+- tests/usage_test.rb
+homepage: http://flori.github.com/cpu
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --title
+- CPU
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: cpu
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: CPU information in Ruby/Linux
+test_files: []
+