sys-cpu 0.6.1 → 0.6.2

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,25 @@
+#######################################################################
+# example_sys_cpu_linux.rb
+#
+# Sample cript for general futzing. You can run this code via the
+# 'rake example' task.
+#
+# Modify as you see fit.
+#######################################################################
+require "sys/cpu"
+require "pp"
+include Sys
+
+puts "VERSION: " + CPU::VERSION
+puts "========"
+
+puts "Load Average: " + CPU.load_avg.join(", ")
+
+puts "Processor Info:"
+puts "==============="
+pp CPU.processors
+
+puts "CPU STATS:"
+puts "=========:"
+
+pp 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

@@ -7,14 +7,20 @@
  * 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>
@@ -27,7 +33,7 @@
 VALUE cCPUError;
 
 /****************************************************************************
- * Used for FreeBSD 4.x to determine CPU clock speed.  Stolen from cpuinfo.c
+ * Used for FreeBSD 4.x to determine CPU clock speed. Borrowed from cpuinfo.c
  * in the MPlayer source code.
  ****************************************************************************/
 #if defined (__FreeBSD__) && (__FreeBSD__ < 5 )
@@ -41,8 +47,8 @@ static int64_t rdtsc(void){
 
 /*
  * call-seq:
- *    CPU.load_average   
- * 
+ *    CPU.load_average
+ *
  * Returns an array of three floats indicating the 1, 5 and 15 minute load
  * average.
  */
@@ -53,14 +59,14 @@ static VALUE cpu_load_avg(VALUE klass){
 
 #ifdef HAVE_KVM_H
    kvm_t* k;
-   
+
    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]));
 
@@ -68,7 +74,7 @@ static VALUE cpu_load_avg(VALUE klass){
 #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));
@@ -76,13 +82,13 @@ static VALUE cpu_load_avg(VALUE klass){
    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));	
+      rb_ary_push(v_num_array, rb_float_new(k.ldavg[n] / (float)k.fscale));
 #endif
 
    return v_num_array;
@@ -107,12 +113,12 @@ static VALUE cpu_num(VALUE klass){
    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);  
+   return INT2NUM(num_cpu);
 }
 
 /*
@@ -132,7 +138,7 @@ static VALUE cpu_model(VALUE klass){
    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
@@ -145,7 +151,8 @@ static VALUE cpu_model(VALUE klass){
  *    CPU.architecture
  *
  * Returns the cpu's architecture. On most systems this will be identical
- * to the CPU.machine method.
+ * 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];
@@ -162,7 +169,11 @@ static VALUE cpu_architecture(VALUE klass){
 #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));
@@ -176,7 +187,8 @@ static VALUE cpu_architecture(VALUE klass){
  *    CPU.machine
  *
  * Returns the cpu's class type. On most systems this will be identical
- * to the CPU.architecture method.
+ * 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];
@@ -188,7 +200,11 @@ static VALUE cpu_machine(VALUE klass){
 #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));
@@ -202,12 +218,12 @@ static VALUE cpu_machine(VALUE klass){
  *    CPU.freq
  *
  * Returns an integer indicating the speed (i.e. frequency in Mhz) of the cpu.
- * 
+ *
  * Not supported on OS X.
  *--
  * Not supported on OS X currently. The sysctl() approach returns a bogus
  * hard-coded value.
- * 
+ *
  * TODO: Fix for OS X.
  */
 static VALUE cpu_freq(VALUE klass){
@@ -216,7 +232,7 @@ static VALUE cpu_freq(VALUE klass){
    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
@@ -226,10 +242,10 @@ static VALUE cpu_freq(VALUE klass){
 #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);
@@ -242,7 +258,7 @@ static VALUE cpu_freq(VALUE klass){
    mib[0] = CTL_KERN;
    mib[1] = KERN_CLOCKRATE;
 
-   if(sysctl(mib, 2, &mhz, &len, NULL, 0)
+   if(sysctl(mib, 2, &mhz, &len, NULL, 0))
       rb_raise(cCPUError,"error calling sysctlbyname(): %s", strerror(errno));
 #endif
 #endif
@@ -265,7 +281,7 @@ void Init_cpu()
     */
    cCPUError = rb_define_class_under(cCPU, "Error", rb_eStandardError);
 
-   /* 0.6.1: The version of this package, returned as a String */
+   /* 0.6.2: The version of the sys-cpu library */
    rb_define_const(cCPU, "VERSION", rb_str_new2(SYS_CPU_VERSION));
 
    /* Class Methods */

data/ext/hpux/hpux.c

@@ -0,0 +1,219 @@
+/*****************************************************************************
+ * hpux.c (cpu.c) - sys-cpu extension for HP-UX
+ *
+ * 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.
+ *****************************************************************************/
+#include <ruby.h>
+#include "version.h"
+#include <unistd.h>
+#include <sys/pstat.h>
+
+#ifndef PST_MAX_PROCS
+#define PST_MAX_PROCS 32
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+VALUE cCPUError;
+
+/*
+ * call-seq:
+ *    CPU.load_avg
+ *    CPU.load_avg(cpu_num)
+ *    CPU.load_avg{ block }
+ *
+ * In non-block form returns an array of three floats indicating the 1, 5
+ * and 15 minute overall load average.
+ *
+ * In block form, it returns an array of three floats indicating the 1, 5
+ * and 15 minute load average for each cpu.  Only useful on multi-cpu
+ * systems.
+ *
+ * If 'cpu_num' is provided, returns the load average (as a 3-element
+ * array) for that cpu only.
+ *
+ * You cannot provide +cpu_num+ and use block form at the same time.
+ */
+static VALUE cpu_load_avg(int argc, VALUE *argv)
+{
+   struct pst_processor psp[PST_MAX_PROCS];
+   struct pst_dynamic psd;
+   int i, num_cpu;
+   VALUE ncpu = Qnil;
+   VALUE la_ary = rb_ary_new();
+
+   rb_scan_args(argc,argv,"01",&ncpu);
+
+   if( (ncpu != Qnil) && (rb_block_given_p()) )
+   {
+      rb_raise(rb_eArgError,"Can't use block form when CPU number is provided");
+   }
+
+   if( (ncpu != Qnil) || ((ncpu == Qnil) && (rb_block_given_p())) )
+   {
+      num_cpu = pstat_getprocessor(psp,sizeof(struct pst_processor),PST_MAX_PROCS,0);
+      if(num_cpu < 0)
+      {
+         rb_raise(cCPUError,"Call to pstat_getprocessor() failed.");
+      }
+      else
+      {
+         for(i = 0; i < num_cpu; i++)
+         {
+            if( (ncpu != Qnil) && (NUM2INT(ncpu)) != i){ continue; }
+
+            rb_ary_push(la_ary,rb_float_new(psp[i].psp_avg_1_min));
+            rb_ary_push(la_ary,rb_float_new(psp[i].psp_avg_5_min));
+            rb_ary_push(la_ary,rb_float_new(psp[i].psp_avg_15_min));
+            if(rb_block_given_p())
+            {
+               rb_yield(la_ary);
+            }
+            else
+            {
+               return la_ary;
+            }
+            rb_ary_clear(la_ary);
+         }
+      }
+   }
+   else
+   {
+      if(pstat_getdynamic(&psd,sizeof(psd), (size_t)1, 0) == -1)
+      {
+         rb_raise(cCPUError,"Call to pstat_getdynamic() failed.");
+      }
+      else
+      {
+         rb_ary_push(la_ary,rb_float_new(psd.psd_avg_1_min));
+         rb_ary_push(la_ary,rb_float_new(psd.psd_avg_5_min));
+         rb_ary_push(la_ary,rb_float_new(psd.psd_avg_15_min));
+         return la_ary;
+      }
+   }
+
+   return Qnil;
+}
+
+/*
+ * call-seq:
+ *    CPU.num_cpu
+ *
+ * Returns the number of CPU's on the system.
+ */
+static VALUE cpu_num()
+{
+   struct pst_dynamic dyn;
+   pstat_getdynamic(&dyn, sizeof(dyn), 0, 0);
+   return INT2NUM(dyn.psd_max_proc_cnt);
+}
+
+/* call-seq:
+ *    CPU.num_active_cpu
+ *
+ * Returns the number of active CPU's on the system.
+ */
+static VALUE cpu_num_active()
+{
+   struct pst_dynamic dyn;
+   pstat_getdynamic(&dyn, sizeof(dyn), 0, 0);
+   return INT2NUM(dyn.psd_proc_cnt);
+}
+
+/*
+ * call-seq:
+ *    CPU.architecture
+ *
+ * Returns the cpu architecture, e.g. PA RISC 1.2, etc, or nil if it
+ * cannot be determined.
+ */
+static VALUE cpu_architecture()
+{
+   long cpu_ver = sysconf(_SC_CPU_VERSION);
+
+   if(cpu_ver == CPU_HP_MC68020){ return rb_str_new2("Motorola MC68020"); }
+   if(cpu_ver == CPU_HP_MC68030){ return rb_str_new2("Motorola MC68030"); }
+   if(cpu_ver == CPU_HP_MC68040){ return rb_str_new2("Motorola MC68040"); }
+   if(cpu_ver == CPU_PA_RISC1_0){ return rb_str_new2("HP PA-RISC 1.0"); }
+   if(cpu_ver == CPU_PA_RISC1_1){ return rb_str_new2("HP PA-RISC 1.1"); }
+   if(cpu_ver == CPU_PA_RISC1_2){ return rb_str_new2("HP PA-RISC 1.2"); }
+   if(cpu_ver == CPU_PA_RISC2_0){ return rb_str_new2("HP PA-RISC 2.0"); }
+
+   return Qnil;
+}
+
+/*
+ * call-seq:
+ *    CPU.freq(cpu_num=0)
+ *
+ * Returns an integer indicating the speed (i.e. frequency in Mhz) of
+ * +cpu_num+, or CPU 0 if no +cpu_num+ is specified.
+ */
+static VALUE cpu_freq(int argc, VALUE *argv)
+{
+   int cpu_num = 0; /* default value */
+   struct pst_processor psp;
+   unsigned long int clock_speed, scclktick;
+   VALUE ncpu = Qnil;
+
+   rb_scan_args(argc, argv, "01", &ncpu);
+
+   if(ncpu != Qnil)
+   {
+      Check_Type(ncpu,T_FIXNUM);
+      cpu_num = NUM2INT(ncpu);
+   }
+
+   if((pstat_getprocessor(&psp,sizeof(psp),(size_t)1,cpu_num)) == -1)
+      rb_raise(cCPUError, "Invalid CPU number?");
+
+   scclktick=sysconf(_SC_CLK_TCK);
+   clock_speed = (psp.psp_iticksperclktick * scclktick) / 1000000;
+
+   /************************************************************************/
+   /* It appears that pstat_getprocessor does not return a failure code    */
+   /* for an invalid processor number.  So, we'll assume that if the clock */
+   /* speed is 0 that an invalid number was provided.                      */
+   /************************************************************************/
+   if(clock_speed <= 0)
+      rb_raise(cCPUError, "Invalid CPU number?");
+
+   return UINT2NUM(clock_speed);
+}
+
+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.2: 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, "freq", cpu_freq, -1);
+   rb_define_singleton_method(cCPU, "num_cpu", cpu_num, 0);
+   rb_define_singleton_method(cCPU, "num_active_cpu", cpu_num_active, 0);
+   rb_define_singleton_method(cCPU, "load_avg", cpu_load_avg, -1);
+   rb_define_singleton_method(cCPU, "architecture", cpu_architecture, 0);
+}
+
+#ifdef __cplusplus
+}
+#endif