sys-cpu 0.6.4-universal-linux

data/doc/linux.txt

@@ -0,0 +1,41 @@
+== Description
+    Sys::CPU - An interface for various cpu statistics
+
+== Synopsis
+    require "sys/cpu"
+    include Sys
+
+    CPU.processors{ |cs|
+       cs.members.each{ |m|
+          puts "#{m}: " + cs[m].to_s
+       }
+    }
+
+    CPU.bogomips(1) # -> returns bogomips for cpu #2
+
+== Notes
+   Portions of this documentation built dynamically
+
+== Constants
+VERSION
+   Returns the current version number for this package as a String.
+
+== Class Methods
+CPU.load_avg
+    Returns an array of three floats indicating the 1, 5 and 15 minute load
+    average.
+
+CPU.cpu_stats
+    Returns a hash, with the cpu number as the key and an array as the value.
+    The array contains the number of seconds that the system spent in
+    user mode, user mode with low priority (nice), system mode, and the
+    idle task, respectively, for that cpu.
+
+CPU.processors{ |cpu struct| block }
+    Calls the block for each processor on your system, passing a CPUStruct as the
+    parameter.
+
+    The exact members of the CPUStruct are the same as the class method names, except
+    for CPU.processors (although you may optionally omit the "?" when referring to a
+    struct member).  These were determined when you installed this package because they
+    vary from one chip architecture to another.

data/doc/sunos.txt

@@ -0,0 +1,56 @@
+== Description
+   Sys::CPU - An interface for various cpu statistics
+   
+== Synopsis
+   require "sys/cpu"
+   include Sys
+
+   # Solaris
+   puts "Mhz: " + CPU.cpu_freq(0).to_s
+   puts "State: " + CPU.state(0)
+   puts "Number of cpu's on this system: " + CPU.num_cpu.to_s
+   puts "CPU type: " + CPU.type
+   puts "FPU type: " + CPU.fpu_type
+   puts "CPU model: " + CPU.model
+   puts "Load averages: " + CPU.load_avg.join(", ")
+   
+== Constants
+VERSION
+   Returns the current version number for this package.
+    
+== Class Methods
+CPU.freq(cpu_num=0)
+   Returns an integer indicating the speed (i.e. frequency in Mhz) of
+   'cpu_num', or CPU 0 if no number is provided.
+    
+CPU.type
+   Returns a string indicating the type of processor.  This is the
+   architecture (e.g. sparcv9), not the exact model (e.g. Ultra-IIe).
+   Returns nil if not found.
+    
+CPU.fpu_type
+   Returns a string indicating the type of floating point unit, or nil if
+   not found.
+    
+CPU.load_avg
+   Returns an array of three floats indicating the 1, 5 and 15 minute load
+   average.
+    
+CPU.model
+   Returns a string indicating the cpu model.  For now, this is the
+   architecture type, rather than the exact model.  However, see the
+   'Future Plans' section below.
+    
+CPU.num_cpu
+   Returns an integer indicating the number of cpu's on the system.
+    
+CPU.state(cpu_num)
+   Returns a string indicating the cpu state of 'cpu_num'.
+    
+== Error Classes
+CPU::Error < StandardError
+   Raised is response to internal function errors, usually relating to an
+   invalid cpu number.
+    
+== More Information
+See the README file for more information.

data/doc/windows.txt

@@ -0,0 +1,130 @@
+== Description
+   Sys::CPU - An interface for various cpu statistics
+    
+== Synopsis
+   require "sys/cpu"
+   include Sys
+
+   CPU.processors{ |cs|
+      cs.members.each{ |m|
+         puts "#{m}: " + cs[m].to_s
+      }
+   }
+
+   puts "CPU Speed (Frequency): " + CPU.freq(0).to_s
+   puts "Load avg: " + CPU.load_avg.to_s
+   puts "Num CPU: " + CPU.num_cpu.to_s
+   puts "Type: " + CPU.type
+   puts "Model: " + CPU.model
+   puts "Architecture: " + CPU.architecture
+    
+== Constants
+VERSION
+   Returns the current version number for this package.
+    
+== Class Methods
+CPU.architecture(host=localhost)
+   Returns the architecture of the cpu, e.g. x86 Family 15 Model 2
+    
+CPU.freq(cpu_num=0, host=localhost)
+   Returns an integer indicating the speed (i.e. frequency in Mhz) of
+   'cpu_num'.  If cpu_num+1 is greater than the number of cpu's on
+   your system, or this call fails for any other reason, a CPUError
+   is raised.
+    
+CPU.load_avg(host=localhost)
+   Returns the load capacity of each processor, averaged to the last second.
+   Processor loading refers to the total computing burden for each
+   processor at one time.
+	
+   Note that this attribute is actually the LoadPercentage.  I may use
+   one of the Win32_Perf* classes in the future.
+	
+CPU.model(host=localhost)
+   Returns a string indicating the cpu model, e.g. Intel Pentium 4
+    
+CPU.num_cpu(host=localhost)
+   Returns an integer indicating the number of cpu's on the system.
+    
+CPU.processors(host=localhost){ |cpu| ... }
+   Returns a CPUStruct for each CPU on the system containing the following
+   members:
+	
+   * address_width
+   * architecture
+   * availability
+   * caption
+   * config_manager_error_code
+   * config_manager_user_config
+   * cpu_status
+   * creation_class_name
+   * freq
+   * voltage
+   * data_width
+   * description
+   * device_id
+   * error_cleared?
+   * error_description
+   * ext_clock
+   * family
+   * install_date
+   * l2_cache_size
+   * l2_cache_speed
+   * last_error_code
+   * level
+   * load_avg
+   * manufacturer
+   * max_clock_speed
+   * name
+   * other_family_description
+   * pnp_device_id
+   * power_management_supported?
+   * power_management_capabilities
+   * processor_id
+   * processor_type
+   * revision
+   * role
+   * socket_designation
+   * status
+   * status_info
+   * stepping
+   * system_creation_class_name
+   * system_name
+   * unique_id
+   * upgrade_method
+   * version
+   * voltage_caps
+   
+   Note that not all of these members will necessarily be defined.  See the
+   NOTES section below.
+    
+CPU.type(host=localhost)
+    Returns a string indicating the type of processor, e.g. GenuineIntel.
+    
+== Exception Classes
+CPU::Error < StandardError
+   Raised is response to internal function errors, most likely to be raised
+   in the event that in invalid cpu number is provided for the 'freq'
+   method.
+    
+== Notes
+   Some of the CPUStruct members may be nil.  As far as I can tell, this
+   means that Windows is unable to determine the value for the attribute due
+   to your BIOS and/or BIOS settings.  There is nothing clear in the
+   documentation I could find for this, however.
+	
+   The 'family' attribute may contain the trademark symbol.
+	
+   The 'status_info' attribute was not converted to a string because the
+   'status' attribute already is a string.  I'm not even sure why MS has both
+   versions.
+	
+   The 'system_name' attribute appears to be the hostname.  I have no idea
+   why this is included as part of the CPU information, but there you go.
+	
+   See http://tinyurl.com/2mros (and click on 'Win32_Processor' in the left
+   frame) for a list of attributes and their meaning.  Link courtesy of
+   tinyurl.com.	
+
+== More Information
+See the README file for more information.

data/examples/example_sys_cpu_bsd.rb

@@ -0,0 +1,19 @@
+#######################################################################
+# example_sys_cpu_bsd.rb
+#
+# Sample cript for general futzing. You can run this code via the
+# 'rake example' task.
+#
+# Modify as you see fit.
+#######################################################################
+require "sys/cpu"
+include Sys
+
+puts "VERSION: " + CPU::VERSION
+
+puts "Load Average: " + CPU.load_avg.join(", ")
+puts "CPU Freq (speed): " + CPU.freq.to_s unless RUBY_PLATFORM.match('darwin')
+puts "Num CPU: " + CPU.num_cpu.to_s
+puts "Architecture: " + CPU.architecture
+puts "Machine: " + CPU.machine
+puts "Model: " + CPU.model

data/examples/example_sys_cpu_hpux.rb

@@ -0,0 +1,27 @@
+#######################################################################
+# example_sys_cpu_hpux.rb
+#
+# Sample cript for general futzing. You can run this code via the
+# 'rake example' task.
+#
+# Modify as you see fit.
+#######################################################################
+require "sys/cpu"
+include Sys
+
+puts "VERSION: " + CPU::VERSION
+puts "========"
+
+puts "Num CPU: " + CPU.num_cpu.to_s
+puts "Active CPU: " + CPU.num_active_cpu.to_s
+puts "Architecture: " + CPU.architecture
+puts "Speed/Freq: " + CPU.freq.to_s
+
+puts "Load average for CPU 0: " + CPU.load_avg(0).join(", ")
+puts "Overall Load Average: " + CPU.load_avg.join(", ")
+
+puts "Individual Loads Averages:"
+puts "=========================="
+CPU.load_avg{ |e|
+   p e
+}

data/examples/example_sys_cpu_linux.rb

@@ -0,0 +1,24 @@
+#######################################################################
+# example_sys_cpu_linux.rb
+#
+# Sample cript for general futzing. You should run this code via the
+# 'rake example' task.
+#
+# Modify as you see fit.
+#######################################################################
+require "sys/cpu"
+require "pp"
+
+puts "VERSION: " + Sys::CPU::VERSION
+puts "========"
+
+puts "Load Average: " + Sys::CPU.load_avg.join(", ")
+
+puts "Processor Info:"
+puts "==============="
+pp Sys::CPU.processors
+
+puts "CPU STATS:"
+puts "=========:"
+
+pp Sys::CPU.cpu_stats

data/examples/example_sys_cpu_sunos.rb

@@ -0,0 +1,21 @@
+#######################################################################
+# example_sys_cpu_sunos.rb
+#
+# Sample cript for general futzing. You can run this code via the
+# 'rake example' task.
+#
+# Modify as you see fit.
+#######################################################################
+require "sys/cpu"
+include Sys
+
+puts "VERSION: " + CPU::VERSION
+puts "========"
+
+puts "Load Average: " + CPU.load_avg.join(", ")
+puts "CPU Freq (speed): " + CPU.freq.to_s
+puts "CPU State: " + CPU.state(0)
+puts "Num CPU: " + CPU.num_cpu.to_s
+puts "Type: " + CPU.cpu_type
+puts "FPU Type: " + CPU.fpu_type
+puts "Model: " + CPU.model

data/examples/example_sys_cpu_windows.rb

@@ -0,0 +1,24 @@
+#######################################################################
+# example_sys_cpu_windows.rb
+#
+# Sample cript for general futzing. You can run this code via the
+# 'rake example' task.
+#
+# Modify as you see fit.
+#######################################################################
+require "sys/cpu"
+include Sys
+
+puts "VERSION: " + CPU::VERSION
+puts "========"
+
+puts "Architecture: " + CPU.architecture.to_s
+puts "CPU Speed (Frequency): " + CPU.freq.to_s
+puts "Load Average: " + CPU.load_average.to_s
+puts "Model: " + CPU.model.to_s
+puts "Type: " + CPU.type.to_s
+puts "Num CPU: " + CPU.num_cpu.to_s
+
+CPU.processors{ |cpu|
+   p cpu
+}

data/ext/bsd/bsd.c

@@ -0,0 +1,331 @@
+/*****************************************************************************
+ * bsd.c (cpu.c) - sys-cpu extension for the various BSD flavors and OS X.
+ *
+ * Author: Daniel J. Berger
+ *
+ * Interface to provide various types of cpu information.
+ * Based on the Unix::Processors Perl module (Wilson Snyder) with ideas from
+ * Sys::CPU (Matt Sanford) and Solaris::Kstat (Alan Burlison) as well.
+ * OS X 10.5+ patch for uptime by Victor Costan.
+ *
+ * Portions of this code lifted from the MPlayer source (cpuinfo.c).
+ *****************************************************************************/
+#include <ruby.h>
+#include "version.h"
+
+#ifdef HAVE_KVM_H
+#include <kvm.h>
+#endif
+
+#if defined (__OpenBSD__)
+#include <sys/param.h>
+#endif
+
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <string.h>
+#include <errno.h>
+
+#ifndef MISSING_USLEEP
+#include <unistd.h>
+#endif
+
+#if defined(__MACH__) && defined(__APPLE__)
+#include <mach/machine.h>
+#endif
+
+VALUE cCPUError;
+
+/****************************************************************************
+ * Used for FreeBSD 4.x to determine CPU clock speed. Borrowed from cpuinfo.c
+ * in the MPlayer source code.
+ ****************************************************************************/
+#if defined (__FreeBSD__) && (__FreeBSD__ < 5 )
+static int64_t rdtsc(void){
+   unsigned int i, j;
+#define RDTSC  ".byte 0x0f, 0x31; "
+   asm(RDTSC : "=a"(i), "=d"(j) : );
+   return ((int64_t)j<<32) + (int64_t)i;
+}
+#endif
+
+/*
+ * call-seq:
+ *    CPU.load_average
+ *
+ * Returns an array of three floats indicating the 1, 5 and 15 minute load
+ * average.
+ */
+static VALUE cpu_load_avg(VALUE klass){
+   int n;
+   VALUE v_num_array = rb_ary_new();
+
+#ifdef HAVE_KVM_H
+  int max = 3;
+  kvm_t* k;
+  double avgs[3];
+
+  k = malloc(sizeof(kvm_t*));
+
+  if(!kvm_getloadavg(k, avgs, max)){
+    free(k);
+    rb_raise(cCPUError, "error calling kvm_getloadavg(): %s", strerror(errno));
+  }
+
+  for(n = 0; n < 3; n++)
+    rb_ary_push(v_num_array, rb_float_new(avgs[n]));
+
+  free(k);
+#else
+	struct loadavg k;
+	size_t len = sizeof(k);
+
+#ifdef HAVE_SYSCTLBYNAME
+  if(sysctlbyname("vm.loadavg", &k, &len, NULL, 0))
+    rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#else
+  int mib[2];
+  mib[0] = CTL_HW;
+  mib[1] = VM_LOADAVG;
+
+  if(sysctl(mib, 2, &k, &len, NULL, 0))
+    rb_raise(cCPUError, "error calling sysctl(): %s", strerror(errno));
+#endif
+  for(n = 0; n < 3; n++)
+    rb_ary_push(v_num_array, rb_float_new(k.ldavg[n] / (float)k.fscale));
+#endif
+
+  return v_num_array;
+}
+
+/*
+ * call-seq:
+ *    CPU.num_cpu
+ *
+ * Returns the number of cpu's on your system. Note that each core on
+ * multi-core systems are counted as a cpu, e.g. one dual core cpu would
+ * return 2, not 1.
+ */
+static VALUE cpu_num(VALUE klass){
+   int num_cpu;
+   size_t len = sizeof(num_cpu);
+
+#ifdef HAVE_SYSCTLBYNAME
+   if(sysctlbyname("hw.ncpu", &num_cpu, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#else
+   int mib[2];
+   mib[0] = CTL_HW;
+   mib[1] = HW_NCPU;
+
+   if(sysctl(mib, 2, &num_cpu, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctl(): %s", strerror(errno));
+#endif
+
+   return INT2NUM(num_cpu);
+}
+
+/*
+ * call-seq:
+ *    CPU.model
+ *
+ * Returns a string indicating the cpu model.
+ *--
+ * On OSX I use the hw.cputype instead of hw.model because OSX returns the
+ * machine model instead of the cpu model for some reason. Initial attempts
+ * to add the cpusubtype as well were unreliable.
+ */
+static VALUE cpu_model(VALUE klass){
+  char model[64];
+  size_t len = sizeof(model);
+
+#ifdef HAVE_SYSCTLBYNAME
+#if defined(__MACH__) && defined(__APPLE__)
+  int cpu_type;
+  len = sizeof(cpu_type);
+
+  if(sysctlbyname("hw.cputype", &cpu_type, &len, NULL, 0))
+#else
+  if(sysctlbyname("hw.model", &model, &len, NULL, 0))
+#endif
+    rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#else
+  int mib[2];
+
+  mib[0] = CTL_HW;
+  mib[1] = HW_MODEL;
+
+  if(sysctl(mib, 2, &model, &len, NULL, 0))
+    rb_raise(cCPUError, "error calling sysctl(): %s", strerror(errno));
+#endif
+
+#if defined(__MACH__) && defined(__APPLE__)
+  // Intel and PowerPC only.
+  switch(cpu_type){
+    case CPU_TYPE_X86:
+    case CPU_TYPE_X86_64:
+      strcpy(model, "Intel");
+      break;
+    case CPU_TYPE_POWERPC:
+    case CPU_TYPE_POWERPC64:
+      strcpy(model, "PowerPC");
+      break;
+    default:
+      strcpy(model, "Unknown"); 
+  }
+
+  // TODO: Add the subtype.
+#endif
+
+  return rb_str_new2(model);
+}
+
+/*
+ * call-seq:
+ *    CPU.architecture
+ *
+ * Returns the cpu's architecture. On most systems this will be identical
+ * to the CPU.machine method. On OpenBSD it will be identical to the CPU.model
+ * method.
+ */
+static VALUE cpu_architecture(VALUE klass){
+   char arch[32];
+   size_t len = sizeof(arch);
+
+#ifdef HAVE_SYSCTLBYNAME
+#if defined(__MACH__) && defined(__APPLE__)
+   if(sysctlbyname("hw.machine", &arch, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#else
+   if(sysctlbyname("hw.machine_arch", &arch, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#endif
+#else
+   int mib[2];
+   mib[0] = CTL_VM;
+#ifdef HW_MACHINE_ARCH
+   mib[1] = HW_MACHINE_ARCH;
+#else
+   mib[1] = HW_MODEL;
+#endif
+
+   if(sysctl(mib, 2, &arch, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctl(): %s", strerror(errno));
+#endif
+
+   return rb_str_new2(arch);
+}
+
+/*
+ * call-seq:
+ *    CPU.machine
+ *
+ * Returns the cpu's class type. On most systems this will be identical
+ * to the CPU.architecture method. On OpenBSD it will be identical to the
+ * CPU.model method.
+ */
+static VALUE cpu_machine(VALUE klass){
+   char machine[32];
+   size_t len = sizeof(machine);
+
+#ifdef HAVE_SYSCTLBYNAME
+   if(sysctlbyname("hw.machine", &machine, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#else
+   int mib[2];
+   mib[0] = CTL_HW;
+#ifdef HW_MACHINE_ARCH
+   mib[1] = HW_MACHINE;
+#else
+   mib[1] = HW_MODEL;
+#endif
+
+   if(sysctl(mib, 2, &machine, &len, NULL, 0))
+      rb_raise(cCPUError, "error calling sysctl(): %s", strerror(errno));
+#endif
+
+   return rb_str_new2(machine);
+}
+
+/*
+ * call-seq:
+ *    CPU.freq
+ *
+ * Returns an integer indicating the speed (i.e. frequency in Mhz) of the cpu.
+ */
+static VALUE cpu_freq(VALUE klass){
+   int mhz;
+#if defined (__FreeBSD__) && (__FreeBSD__ < 5)
+   int64_t tsc_start, tsc_end;
+   struct timeval tv_start, tv_end;
+   int usec_delay;
+
+   tsc_start = rdtsc();
+   gettimeofday(&tv_start,NULL);
+#ifdef MISSING_USLEEP
+   sleep(1);
+#else
+   usleep(100000);
+#endif
+   tsc_end = rdtsc();
+   gettimeofday(&tv_end,NULL);
+
+   usec_delay = 1000000 * (tv_end.tv_sec - tv_start.tv_sec)
+      + (tv_end.tv_usec - tv_start.tv_usec);
+
+   mhz = ((tsc_end - tsc_start) / usec_delay);
+#else
+   size_t len = sizeof(mhz);
+#ifdef HAVE_SYSCTLBYNAME
+#if defined(__MACH__) && defined(__APPLE__)
+   size_t freq;
+   len = sizeof(freq);
+
+   if(sysctlbyname("hw.cpufrequency", &freq, &len, 0, 0))
+      rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+
+   mhz = freq / 1000000;
+#else
+   if(sysctlbyname("hw.clockrate", &mhz, &len, 0, 0))
+      rb_raise(cCPUError, "error calling sysctlbyname(): %s", strerror(errno));
+#endif
+#else
+   int mib[2];
+
+   mib[0] = CTL_KERN;
+   mib[1] = KERN_CLOCKRATE;
+
+   if(sysctl(mib, 2, &mhz, &len, NULL, 0))
+      rb_raise(cCPUError,"error calling sysctlbyname(): %s", strerror(errno));
+#endif
+#endif
+
+   return INT2NUM(mhz);
+}
+
+void Init_cpu()
+{
+   VALUE mSys, cCPU;
+
+   /* The Sys module serves as a toplevel namespace only */
+   mSys = rb_define_module("Sys");
+
+   /* The CPU class provides class methods for obtaining CPU information */
+   cCPU = rb_define_class_under(mSys, "CPU", rb_cObject);
+
+   /* The CPU::Error Exception class is raised whenever any of the CPU class
+    * methods fail.
+    */
+   cCPUError = rb_define_class_under(cCPU, "Error", rb_eStandardError);
+
+   /* 0.6.4: The version of the sys-cpu library */
+   rb_define_const(cCPU, "VERSION", rb_str_new2(SYS_CPU_VERSION));
+
+   /* Class Methods */
+   rb_define_singleton_method(cCPU, "architecture", cpu_architecture, 0);
+   rb_define_singleton_method(cCPU, "freq", cpu_freq, 0);
+   rb_define_singleton_method(cCPU, "load_avg", cpu_load_avg, 0);
+   rb_define_singleton_method(cCPU, "machine", cpu_machine, 0);
+   rb_define_singleton_method(cCPU, "model", cpu_model, 0);
+   rb_define_singleton_method(cCPU, "num_cpu", cpu_num, 0);
+}