sys-cpu 1.0.2 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b8cf15d0019738569df3847184952320df08960cc039e52ed819ae7a649d3f
-  data.tar.gz: b38dc203121fa564f8c6d156e99821eb33ea1b7db7070e261262458531b7393a
+  metadata.gz: 7093a05a67945ccf9980c070421462c4a30a40d72ba9645230fad1d86381c0c1
+  data.tar.gz: e411d1a7f0ce381fcd8660e9b7654d60c21c03459b25cb6cdd1b46c379196b10
 SHA512:
-  metadata.gz: 7bbce2f399977b559cbbd799b0b2fb9c5343627e316d8d8c1a58fd61878452491ffd3bf4dc18851c1a8c76d383b7b9aea2e9f7b8bae03e465fd94cd602f1e802
-  data.tar.gz: 1ac9b193bf154c24b884ac0638a6bc2ff7ee959adaf0dac0d05eb8e47a4f4eadbc5e0f019cd50100cc5e30c0ac02ec8db6f10c89b1acf3404f30f64ea5341818
+  metadata.gz: ff952395b1f70fedc9f01818efff2c4655ed19f2120351a84eec82690176a6de5664ca1b17648656b8eeaacaccc805c5077f4c50d79ad2983f1b3df92f14e6a8
+  data.tar.gz: 07344e7816c0ccb3bc2217c4563d2c3c97875bd3e45cc8b463cd516b44f2cc38ba94df7798ae9e086886bd0bbcdae5da514244a19165f0d732c2ddb5179d85ca

data/CHANGES.md

@@ -1,3 +1,26 @@
+## 1.0.5 - 10-Aug-2022
+* Updated the cpu detection handling for Mac M1 systems. Thanks go to
+  Julien W for the spot.
+
+## 1.0.4 - 10-Jun-2022
+* The OSX code for the CPU.freq method was updated for arm64 systems.
+* Some refactoring to the specs and uses shared examples now.
+* Now makes the new method a private class method. The constructor was never
+  meant to be used with this library, so now it's explicitly forbidden.
+* Added rubocop and rubocop-rspec as development dependencies, as well as
+  a rubocop rake task, and applied some suggested changes.
+* Fixed the global Gemfile source issue. Just use the gemspec.
+* Added some new cpu families for Windows.
+* Added a respond_to_missing? method to the Linux version since it uses
+  method_missing.
+* The MS Windows version now assumes Ruby 2.0 or later.
+
+## 1.0.3 - 28-Jan-2021
+* The code for OSX was split out into its own source file. This was partly for
+  ease of maintenance, but also because there was confusion with the
+  processor_info function. The original function was only aimed at Solaris, but
+  it turns out OSX has its own, different implementation. This caused segfaults.
+
 ## 1.0.2 - 25-Jan-2021
 * Fixed issues where things that were meant to be private weren't actually private.
 

data/Gemfile

@@ -1,7 +1,2 @@
-source 'https://rubygems.org' do
-  gem 'ffi', '~> 1.1'
-  group 'test' do
-    gem 'rake'
-    gem 'rspec', '~> 3.9'
-  end
-end
+source 'https://rubygems.org'
+gemspec

data/MANIFEST.md

@@ -17,6 +17,7 @@
 * examples/example_sys_cpu_sunos.rb
 * examples/example_sys_cpu_windows.rb
 * lib/sys/cpu.rb
+* lib/sys/darwin/sys/cpu.rb
 * lib/sys/linux/sys/cpu.rb
 * lib/sys/unix/sys/cpu.rb
 * lib/sys/windows/sys/cpu.rb

data/README.md

@@ -1,3 +1,9 @@
+[![Ruby](https://github.com/djberg96/sys-cpu/actions/workflows/ruby.yml/badge.svg)](https://github.com/djberg96/sys-cpu/actions/workflows/ruby.yml)
+
+* Linux
+* Windows
+* OSX
+
 ## Description
 A Ruby interface for getting cpu information.
 
@@ -5,15 +11,16 @@ A Ruby interface for getting cpu information.
 `gem install sys-cpu`
 
 ## Adding the trusted cert
-`gem cert --add <(curl -Ls https://raw.githubusercontent.com/djberg96/sys-cpu/ffi/certs/djberg96_pub.pem)`
+`gem cert --add <(curl -Ls https://raw.githubusercontent.com/djberg96/sys-cpu/main/certs/djberg96_pub.pem)`
 
 ## Notes
 ### Solaris
-Currently there is no +processors+ iterative method for multi-cpu systems.
-I plan to add it this in a future release.
+There is no `processors` iterative method for multi-cpu systems. I was going to
+add this originally, but since Solaris is basically dead at this point I've
+dropped the idea.
    
 ### OS X
-The CPU.model method returns very limited information. I do not yet know
+The `CPU.model` method returns very limited information. I do not yet know
 how to get more detailed information.
 
 ### Linux
@@ -21,14 +28,14 @@ This is pure Ruby. This version reads information out of /proc/cpuinfo and
 /proc/loadavg, so if /proc isn't mounted it won't work.
 
 The key-value information in /proc/cpuinfo is stored internally (i.e. in
-memory) as an array of hashes when you first +require+ this package. This
+memory) as an array of hashes when you first `require` this package. This
 overhead is exceptionally minimal, given that your average cpuinfo file
 contains less than 1k of text (and I don't store whitespace or newlines).
 
 The text documentation for Linux is dynamically generated during the
 build process because the fields vary depending on your setup. So, don't
-look at it until *after* you've installed it.  You will see a doc/linux.txt
-file after you run +rake install+ (via install.rb).
+look at it until *after* you've installed it. You will see a doc/linux.txt
+file after you run `rake install` (via install.rb).
 
 ### HP-UX
 Unlike other platforms, you can get load averages for an individual cpu in
@@ -42,10 +49,10 @@ will work just fine.
 This is a pure Ruby implementation using the win32ole package + WMI. The C
 version has been scrapped. 
 
-As of version 0.5.0, the CPU.usage method has been removed in favor of the
-CPU.load_avg method. This does not (currently) use a perf counter, so there
-is no longer any delay. Also, the +processors+ method has been added and the
-+supported+ method has been dropped. See the documentation for other changes.
+As of version 0.5.0, the `CPU.usage` method has been removed in favor of the
+`CPU.load_avg` method. This does not (currently) use a perf counter, so there
+is no longer any delay. Also, the `processors` method has been added and the
+`supported` method has been dropped. See the documentation for other changes.
    
 ## Acknowledgements
 Thanks go to the MPlayer team for some source code that helped me on
@@ -57,14 +64,14 @@ None that I'm aware of. Please report bugs on the project page at:
 https://github.com/djberg96/sys-cpu
 
 ## Future Plans
-* Add iterative CPU.processors method.
-* Add more information in general, such as what +prtdiag+ shows.
+* Add iterative `CPU.processors` method.
+* Add more information in general, such as what `prtdiag` shows.
 
 ## License
 Apache-2.0
 
 ## Copyright
-(C) 2003-2021 Daniel J. Berger, All Rights Reserved
+(C) 2003-2022 Daniel J. Berger, All Rights Reserved
 
 ## Warranty
 This package is provided "as is" and without any express or

data/Rakefile

@@ -2,6 +2,7 @@ require 'rake'
 require 'rake/clean'
 require 'rbconfig'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 include RbConfig
 
 CLEAN.include('**/*.gem', '**/*.rbc', '**/*.rbx', '**/*.lock')
@@ -10,7 +11,7 @@ namespace 'gem' do
   desc "Create the sys-cpu gem"
   task :create => [:clean] do
     require 'rubygems/package'
-    spec = eval(IO.read('sys-cpu.gemspec'))
+    spec = Gem::Specification.load('sys-cpu.gemspec')
     spec.signing_key = File.join(Dir.home, '.ssh', 'gem-private_key.pem')
     Gem::Package.build(spec)
   end
@@ -44,6 +45,8 @@ task :example => [:clean] do
 
 end
 
+RuboCop::RakeTask.new
+
 desc "Run the test suite"
 RSpec::Core::RakeTask.new(:spec)
 

data/doc/bsd.md

@@ -0,0 +1,58 @@
+## Description
+
+A Ruby interface for various cpu statistics
+   
+## Synopsis
+```ruby
+  require 'sys/cpu' # or 'sys-cpu'
+
+  # BSD and OS X
+  puts "Architecture: " + Sys::CPU.architecture
+  puts "Machine: " + Sys::CPU.machine
+  puts "Mhz: " + Sys::CPU.cpu_freq.to_s
+  puts "Number of cpu's on this system: " + Sys::CPU.num_cpu.to_s
+  puts "CPU model: " + Sys::CPU.model
+  puts "Load averages: " + Sys::CPU.load_avg.join(", ")
+```
+   
+## Constants
+`VERSION`
+
+Returns the current version number for this library.
+    
+## Singleton Methods
+
+`CPU.architecture`
+
+Returns the cpu's architecture, e.g. "x86_64".
+
+`CPU.freq`
+
+Returns an integer indicating the speed (i.e. frequency in Mhz) of
+the cpu.
+   
+`CPU.load_avg`
+
+Returns an array of three floats indicating the 1, 5 and 15 minute load
+average.
+
+`CPU.machine`
+
+Returns the class of cpu (probably identical to the architecture).
+
+`CPU.model`
+
+Returns a string indicating the cpu model, e.g. "Intel".
+    
+`CPU.num_cpu`
+
+Returns an integer indicating the number of cpu's on the system.
+    
+## Error Classes
+`CPU::Error < StandardError`
+
+Raised is response to internal function errors, usually relating to an
+invalid cpu number.
+    
+## More Information
+See the `README.md` file for more information.

data/doc/linux.md

@@ -0,0 +1,46 @@
+## Description
+Sys::CPU - An interface for various cpu statistics
+
+## Synopsis
+```ruby
+require 'sys-cpu' # Or "sys/cpu"
+
+Sys::CPU.processors{ |cs|
+  cs.members.each{ |m|
+    puts "#{m}: " + cs[m].to_s
+  }
+}
+
+Sys::CPU.bogomips(1) # -> returns bogomips for cpu #2
+```
+
+## Notes
+
+Portions of this documentation were built dynamically.
+
+## Constants
+
+VERSION
+
+Returns the current version number for this library 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| ... }`
+
+Calls the block for each processor on your system, yielding a `CPUStruct` to the block.
+
+The exact members of the `CPUStruct` are the same as the singleton method names, except
+for `Sys::CPU.processors` (although you may optionally omit the "?" when referring to a
+struct member). These were determined when you installed this library because they
+vary from one chip architecture to another.

data/install.rb

@@ -31,7 +31,7 @@ end
 #######################################################################
 if CONFIG['host_os'] =~ /linux/
   cpu_file  = "/proc/cpuinfo"
-  text_file = "doc/linux.txt"
+  text_file = "doc/linux.md"
   rb_file   = "lib/linux/sys/cpu.rb"
 
   if File.size(text_file) > 1400
@@ -44,7 +44,7 @@ if CONFIG['host_os'] =~ /linux/
     IO.foreach(cpu_file){ |line|
       next if line =~ /^$/
       k,v = line.split(":")
-         
+
       v = v.strip.chomp
       k = k.strip.gsub(/\s+/, '_').downcase
 

data/lib/sys/cpu.rb

@@ -1,11 +1,18 @@
+# frozen_string_literal: true
+
 # This is just a stub file that requires the appropriate version
 # depending on which platform you're on.
 require 'rbconfig'
 
+# The Sys module is a namespace only.
 module Sys
+  # The CPU class encapsulates information about the physical cpu's on your system.
+  # This class is reopened for each of the supported platforms/operating systems.
   class CPU
     # The version of the sys-cpu gem.
-    VERSION = '1.0.2'.freeze
+    VERSION = '1.0.5'
+
+    private_class_method :new
   end
 end
 
@@ -14,6 +21,8 @@ case RbConfig::CONFIG['host_os']
     require_relative('linux/sys/cpu')
   when /windows|mswin|mingw|cygwin|dos/i
     require_relative('windows/sys/cpu')
+  when /darwin|mach|osx/i
+    require_relative('darwin/sys/cpu')
   else
     require_relative('unix/sys/cpu')
 end

data/lib/sys/darwin/sys/cpu.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'rbconfig'
+
+# The Sys module serves as a namespace only.
+module Sys
+  # The CPU class encapsulates information about the physical cpu's on your system.
+  class CPU
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    # Error raised if any of the CPU methods fail.
+    class Error < StandardError; end
+
+    CTL_HW = 6 # Generic hardware/cpu
+
+    HW_MACHINE      = 1  # Machine class
+    HW_MODEL        = 2  # Specific machine model
+    HW_NCPU         = 3  # Number of CPU's
+    HW_CPU_FREQ     = 15 # CPU frequency
+    HW_MACHINE_ARCH = 12 # Machine architecture
+
+    SI_MACHINE          = 5
+    SI_ARCHITECTURE     = 6
+    SC_NPROCESSORS_ONLN = 15
+
+    P_OFFLINE  = 1
+    P_ONLINE   = 2
+    P_FAULTED  = 4
+    P_POWEROFF = 5
+    P_NOINTR   = 6
+    P_SPARE    = 7
+
+    CPU_ARCH_ABI64     = 0x01000000
+    CPU_TYPE_X86       = 7
+    CPU_TYPE_X86_64    = (CPU_TYPE_X86 | CPU_ARCH_ABI64)
+    CPU_TYPE_SPARC     = 14
+    CPU_TYPE_POWERPC   = 18
+    CPU_TYPE_POWERPC64 = CPU_TYPE_POWERPC | CPU_ARCH_ABI64
+
+    attach_function(
+      :sysctl,
+      %i[pointer uint pointer pointer pointer size_t],
+      :int
+    )
+
+    private_class_method :sysctl
+
+    attach_function(
+      :sysctlbyname,
+      %i[string pointer pointer pointer size_t],
+      :int
+    )
+
+    private_class_method :sysctlbyname
+
+    attach_function :getloadavg, %i[pointer int], :int
+    attach_function :processor_info, %i[int int string pointer pointer], :int
+    attach_function :sysconf, [:int], :long
+
+    private_class_method :getloadavg
+    private_class_method :processor_info
+    private_class_method :sysconf
+
+    class ClockInfo < FFI::Struct
+      layout(
+        :hz, :int,
+        :tick, :int,
+        :spare, :int,
+        :stathz, :int,
+        :profhz, :int
+      )
+    end
+
+    # 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.
+    #
+    def self.architecture
+      optr = FFI::MemoryPointer.new(:char, 256)
+      size = FFI::MemoryPointer.new(:size_t)
+
+      size.write_int(optr.size)
+
+      if sysctlbyname('hw.machine', optr, size, nil, 0) < 0
+        raise Error, 'sysctlbyname function failed'
+      end
+
+      optr.read_string
+    end
+
+    # 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.
+    #
+    def self.num_cpu
+      optr = FFI::MemoryPointer.new(:long)
+      size = FFI::MemoryPointer.new(:size_t)
+
+      size.write_long(optr.size)
+
+      if sysctlbyname('hw.ncpu', optr, size, nil, 0) < 0
+        raise Error, 'sysctlbyname failed'
+      end
+
+      optr.read_long
+    end
+
+    # 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.
+    #
+    def self.machine
+      buf  = 0.chr * 32
+      mib  = FFI::MemoryPointer.new(:int, 2)
+      size = FFI::MemoryPointer.new(:long, 1)
+
+      mib.write_array_of_int([CTL_HW, HW_MACHINE])
+      size.write_int(buf.size)
+
+      if sysctl(mib, 2, buf, size, nil, 0) < 0
+        raise Error, 'sysctl function failed'
+      end
+
+      buf.strip
+    end
+
+    # Returns a string indicating the cpu model.
+    #
+    def self.model
+      ptr  = FFI::MemoryPointer.new(:long)
+      size = FFI::MemoryPointer.new(:size_t)
+
+      size.write_long(ptr.size)
+
+      if sysctlbyname('hw.cputype', ptr, size, nil, 0) < 0
+        raise 'sysctlbyname function failed'
+      end
+
+      case ptr.read_long
+        when  CPU_TYPE_X86, CPU_TYPE_X86_64
+          'Intel'
+        when CPU_TYPE_SPARC
+          'Sparc'
+        when CPU_TYPE_POWERPC, CPU_TYPE_POWERPC64
+          'PowerPC'
+        else
+          'Unknown'
+      end
+    end
+
+    # Returns an integer indicating the speed of the CPU.
+    #
+    def self.freq
+      optr = FFI::MemoryPointer.new(:long)
+      size = FFI::MemoryPointer.new(:size_t)
+
+      size.write_long(optr.size)
+
+      if RbConfig::CONFIG['host_cpu'] =~ /^arm|^aarch/i
+        if sysctlbyname('hw.tbfrequency', optr, size, nil, 0) < 0
+          raise Error, 'sysctlbyname failed on hw.tbfrequency'
+        end
+
+        size.clear
+        clock = ClockInfo.new
+        size.write_long(clock.size)
+
+        if sysctlbyname('kern.clockrate', clock, size, nil, 0) < 0
+          raise Error, 'sysctlbyname failed on kern.clockrate'
+        end
+
+        (optr.read_long * clock[:hz]) / 1_000_000
+      else
+        if sysctlbyname('hw.cpufrequency', optr, size, nil, 0) < 0
+          raise Error, 'sysctlbyname failed on hw.cpufrequency' if result < 0
+        end
+        optr.read_long / 1_000_000
+      end
+    end
+
+    # Returns an array of three floats indicating the 1, 5 and 15 minute load
+    # average.
+    #
+    def self.load_avg
+      loadavg = FFI::MemoryPointer.new(:double, 3)
+
+      if getloadavg(loadavg, loadavg.size) < 0
+        raise Error, 'getloadavg function failed'
+      end
+
+      loadavg.get_array_of_double(0, 3)
+    end
+  end
+end

data/lib/sys/linux/sys/cpu.rb

@@ -1,48 +1,48 @@
+# frozen_string_literal: true
+
 ##########################################################
 # linux.rb (sys-cpu) - pure Ruby version for Linux
 ##########################################################
-module Sys
 
+# The Sys module is a namespace only.
+module Sys
   # :stopdoc:
 
-  cpu_file   = '/proc/cpuinfo'
-  cpu_hash   = {}
+  cpu_file  = '/proc/cpuinfo'
+  cpu_hash  = {}
   CPU_ARRAY = []
 
   private_constant :CPU_ARRAY
 
   # Parse the info out of the /proc/cpuinfo file
-  IO.foreach(cpu_file){ |line|
+  File.foreach(cpu_file) do |line|
     line.strip!
     next if line.empty?
 
     key, val = line.split(':')
     key.strip!
-    key.gsub!(/\s+/,'_')
+    key.gsub!(/\s+/, '_')
     key.downcase!
     val.strip! if val
 
-    if cpu_hash.has_key?(key)
+    if cpu_hash.key?(key)
       CPU_ARRAY.push(cpu_hash.dup)
       cpu_hash.clear
     end
 
     # Turn yes/no attributes into booleans
-    if val == 'yes'
-      val = true
-    elsif val == 'no'
-      val = false
-    end
+    val = true if val == 'yes'
+    val = false if val == 'no'
 
     cpu_hash[key] = val
-  }
+  end
 
   CPU_ARRAY.push(cpu_hash)
 
   # :startdoc:
 
+  # The CPU class encapsulates information about physical CPUs on your system.
   class CPU
-
     # :stopdoc:
 
     CPUStruct = Struct.new('CPUStruct', *CPU_ARRAY.first.keys)
@@ -58,15 +58,15 @@ module Sys
     #
     def self.processors
       array = []
-      CPU_ARRAY.each{ |hash|
+      CPU_ARRAY.each do |hash|
         struct = CPUStruct.new
-        struct.members.each{ |m| struct.send("#{m}=", hash["#{m}"]) }
+        struct.members.each{ |m| struct.send("#{m}=", hash[m.to_s]) }
         if block_given?
           yield struct
         else
           array << struct
         end
-      }
+      end
       array unless block_given?
     end
 
@@ -80,12 +80,10 @@ module Sys
     #
     def self.architecture
       case CPU_ARRAY.first['cpu_family']
-      when '3'
-        'x86'
-      when '6'
-        'x86_64'
-      else
-        nil
+        when '3'
+          'x86'
+        when '6'
+          'x86_64'
       end
     end
 
@@ -103,16 +101,20 @@ module Sys
 
     # Create singleton methods for each of the attributes.
     #
-    def self.method_missing(id, arg=0)
-      raise NoMethodError, "'#{id}'" unless CPU_ARRAY[arg].has_key?(id.to_s)
+    def self.method_missing(id, arg = 0)
+      raise NoMethodError, "'#{id}'" unless CPU_ARRAY[arg].key?(id.to_s)
       rv = CPU_ARRAY[arg][id.to_s]
       if rv.nil?
-        id = id.to_s + '?'
+        id = "#{id}?"
         rv = CPU_ARRAY[arg][id]
       end
       rv
     end
 
+    def self.respond_to_missing?(method, _private_methods = false)
+      CPU_ARRAY.first.keys.include?(method.to_s)
+    end
+
     private_class_method :method_missing
 
     # Returns a 3 element Array corresponding to the 1, 5 and 15 minute
@@ -120,7 +122,7 @@ module Sys
     #
     def self.load_avg
       load_avg_file = '/proc/loadavg'
-      IO.readlines(load_avg_file).first.split[0..2].map{ |e| e.to_f }
+      File.readlines(load_avg_file).first.split[0..2].map(&:to_f)
     end
 
     # Returns a hash of arrays that contains an array of the following
@@ -143,21 +145,21 @@ module Sys
       cpu_stat_file = '/proc/stat'
       hash = {} # Hash needed for multi-cpu systems
 
-      lines = IO.readlines(cpu_stat_file)
+      lines = File.readlines(cpu_stat_file)
 
-      lines.each_with_index{ |line, i|
+      lines.each_with_index do |line, i|
         array = line.split
-        break unless array[0] =~ /cpu/   # 'cpu' entries always on top
+        break unless array[0] =~ /cpu/ # 'cpu' entries always on top
 
         # Some machines list a 'cpu' and a 'cpu0'. In this case only
         # return values for the numbered cpu entry.
-        if lines[i].split[0] == 'cpu' && lines[i+1].split[0] =~ /cpu\d/
+        if lines[i].split[0] == 'cpu' && lines[i + 1].split[0] =~ /cpu\d/
           next
         end
 
         vals = array[1..-1].map{ |e| e.to_i / 100 } # 100 jiffies/sec.
         hash[array[0]] = vals
-      }
+      end
 
       hash
     end