linux_stat 0.7.4 → 0.9.2

data/lib/linux_stat/cpu.rb

@@ -2,7 +2,7 @@ module LinuxStat
 	module CPU
 		class << self
 			##
-			# = stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# Where sleep is the delay to gather the data.
 			#
@@ -14,18 +14,20 @@ module LinuxStat
 			#
 			# And the consecutive ones are the real core usages.
 			#
-			# On a system with 4 threads, the output will be like::
-			#    {0=>84.38, 1=>100.0, 2=>50.0, 3=>87.5, 4=>87.5}
+			# For example, on a system with 4 threads:
+			#    LinuxStat::CPU.stat
+			#
+			#    => {0=>84.38, 1=>100.0, 2=>50.0, 3=>87.5, 4=>87.5}
 			#
 			# If the information is not available, it will return an empty Hash
-			def stat(sleep = ticks_to_ms)
+			def stat(sleep = ticks_to_ms_t5)
 				return {} unless stat?
 
-				data = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
+				data = IO.readlines('/proc/stat'.freeze).select { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
 				sleep(sleep)
-				data2 = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
+				data2 = IO.readlines('/proc/stat'.freeze).select { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
 
-				# On devices like android, the core count can change anytime.
+				# On devices like android, the core count can change anytime (hotplugging).
 				# I had crashes on Termux.
 				# So better just count the min number of CPU and iterate over that
 				# If data.length is smaller than data2.length, we don't have enough data to compare.
@@ -39,12 +41,10 @@ module LinuxStat
 					idle_then, idle_now  = idle + iowait, idle2 + iowait2
 					totald = idle_now.+(user2 + nice2 + sys2 + irq2 + softirq2 + steal2) - idle_then.+(user + nice + sys + irq + softirq + steal)
 
-					res = totald.-(idle_now - idle_then).fdiv(totald).*(100).round(2).abs
-					res = 0.0 if res.nan?
+					res = totald.-(idle_now - idle_then).fdiv(totald).abs.*(100)
+					res = res.nan? ? 0.0 : res > 100 ? 100.0 : res.round(2)
 
-					h.merge!(
-						x => res
-					)
+					h.merge!( x => res )
 				end
 			end
 
@@ -60,28 +60,119 @@ module LinuxStat
 			# It's like running LinuxStat::CPU.stat[0] but it's much more efficient and calculates just the aggregated usage which is available at the top of the /proc/stat file.
 			#
 			# If the information is not available, it will return nil.
-			def total_usage(sleep = ticks_to_ms)
+			def total_usage(sleep = ticks_to_ms_t5)
 				return nil unless stat?
 
-				data = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
+				data = IO.foreach('/proc/stat'.freeze).first.split.tap(&:shift).map!(&:to_f)
 				sleep(sleep)
-				data2 = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
+				data2 = IO.foreach('/proc/stat'.freeze).first.split.tap(&:shift).map!(&:to_f)
 
 				user, nice, sys, idle, iowait, irq, softirq, steal = *data
 				user2, nice2, sys2, idle2, iowait2, irq2, softirq2, steal2 = *data2
 
 				idle_then, idle_now  = idle + iowait, idle2 + iowait2
 				totald = idle_now.+(user2 + nice2 + sys2 + irq2 + softirq2 + steal2) - idle_then.+(user + nice + sys + irq + softirq + steal)
-				totald.-(idle_now - idle_then).fdiv(totald).*(100).round(2).abs
+
+				u = totald.-(idle_now - idle_then).fdiv(totald).abs.*(100)
+				u > 100 ? 100.0 : u.round(2)
 			end
 
 			##
-			# Returns the total number of CPU threads.
+			# Returns the total number of CPU available for the sysetm.
+			#
+			# It returns an Integer.
 			#
-			# If the information isn't available, it will return 0.
+			# If the information isn't available, it will return nil.
 			def count
-				# CPU count can change during the program runtime
-				cpuinfo.count { |x| x.start_with?('processor') }
+				@@cpu_count ||= LinuxStat::Sysconf.processor_configured
+			end
+
+			##
+			# Returns the total number of CPU online in the sysetm.
+			#
+			# It first reads /proc/stat, if that fails, it will
+			# read /sys/devices/system/cpu/online,
+			# if that fails it will open /proc/cpuinfo.
+			# If neither of the procedures work, it will get the
+			# LinuxStat::Sysconf.processor_online
+			#
+			# It opens /sys/devices/system/cpu/offline and
+			# performs various job to get one Ruby array.
+			#
+			# If the information isn't available, it will return an empty Array.
+			def count_online
+				@@cpuinfo_file ||= '/proc/cpuinfo'.freeze
+				@@cpuinfo_readable ||= File.readable?(@@cpuinfo_file)
+
+				@@stat_file ||= '/proc/stat'.freeze
+
+				# Not much slow, not blazing fast, somewhat reliable
+				get_online = online
+
+				if !get_online.empty?
+					get_online.length
+				elsif @@cpuinfo_readable
+					# Way slower but reliable!
+					IO.readlines(@@cpuinfo_file).count { |x| x.strip[/\Aprocessor.*\d*\z/] }
+				else
+					# Way faster but absolutely unrealiable!
+					LinuxStat::Sysconf.processor_online
+				end
+			end
+
+			##
+			# Returns the total number of CPU online in the sysetm.
+			#
+			# It will read /proc/stat to get the info.
+			#
+			# If the info isn't available, it reads /sys/devices/system/cpu/onfline and
+			# performs various job to get one Ruby array.
+			#
+			# If the information isn't available, it will return an empty Array.
+			def online
+				@@online_file ||= '/sys/devices/system/cpu/online'.freeze
+				@@online_readable ||= File.readable?(@@online_file)
+
+				@@stat_file ||= '/proc/stat'.freeze
+
+				ret = []
+
+				if stat?
+					IO.readlines(@@stat_file).map { |x|
+						v = x.strip[/\Acpu\d*/] &.[](/\d/)
+						ret << v.to_i if v
+					}
+				elsif @@online_readable
+					IO.read(@@online_file).split(?,.freeze).each { |x|
+						x.strip!
+						c = x.split(?-.freeze).map(&:to_i)
+						ret.concat(c.length == 2 ? Range.new(*c).to_a : c)
+					}
+				end
+
+				ret
+			end
+
+			##
+			# Returns the total number of CPU offline in the sysetm.
+			#
+			# It opens /sys/devices/system/cpu/offline and
+			# performs various job to get one Ruby array.
+			#
+			# If the information isn't available, it will return an empty Array.
+			def offline
+				@@offline_file ||= '/sys/devices/system/cpu/offline'.freeze
+				@@offline_readable ||= File.readable?(@@offline_file)
+				return [] unless @@offline_readable
+
+				ret = []
+				IO.read(@@offline_file).split(?,.freeze).each { |x|
+					x.strip!
+					c = x.split(?-.freeze).map(&:to_i)
+					ret.concat(c.length == 2 ? Range.new(*c).to_a : c)
+				}
+
+				ret
 			end
 
 			##
@@ -95,33 +186,115 @@ module LinuxStat
 			end
 
 			##
-			# Returns an array with current core frequencies corresponding to the usages.
+			# Returns a Hash with current core frequencies corresponding to the CPUs.
+			#
+			# For example:
+			#    LinuxStat::CPU.cur_freq
 			#
-			# If the information isn't available, it will return an empty array.
+			#    => {"cpu0"=>1999990, "cpu1"=>2000042, "cpu2"=>2000016, "cpu3"=>2000088}
+			#
+			# If the information isn't available, it will return an empty Hash.
 			def cur_freq
-				@@cpu_freqs ||= Dir["/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq"]
-				@@cur_freqs_readable ||= @@cpu_freqs.all?(&File.method(:readable?))
+				@@cur_f ||= cpus.map { |x|
+					[File.split(x)[-1], File.join(x, 'cpufreq/scaling_cur_freq'.freeze)]
+				}
 
-				if @@cur_freqs_readable
-					@@cpu_freqs.map { |x| IO.read(x).to_i }
-				else
-					[]
-				end
+				h = {}
+				@@cur_f.each { |id, file|
+					h.merge!(id => IO.read(file).to_i) if File.readable?(file)
+				}
+
+				h
 			end
 
 			##
-			# Returns an array with max core frequencies corresponding to the usages.
+			# Returns a Hash with max core frequencies corresponding to the CPUs.
+			#
+			# For example:
+			#    LinuxStat::CPU.min_freq
 			#
-			# If the information isn't available, it will return an empty array.
+			#    => {"cpu0"=>2000000, "cpu1"=>2000000, "cpu2"=>2000000, "cpu3"=>2000000}
+			#
+			# If the information isn't available, it will return an empty Hash.
+			def min_freq
+				@@min_f ||= cpus.map { |x|
+					[File.split(x)[-1], File.join(x, 'cpufreq/scaling_min_freq'.freeze)]
+				}
+
+				h = {}
+				@@min_f.each { |id, file|
+					h.merge!(id => IO.read(file).to_i) if File.readable?(file)
+				}
+
+				h
+			end
+
+			##
+			# Returns a Hash with max core frequencies corresponding to the CPUs.
+			#
+			# For example:
+			#    LinuxStat::CPU.max_freq
+			#
+			#    => {"cpu0"=>2000000, "cpu1"=>2000000, "cpu2"=>2000000, "cpu3"=>2000000}
+			#
+			# If the information isn't available, it will return an empty Hash.
 			def max_freq
-				@@max_freqs ||= Dir["/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_max_freq"]
-				@@max_freqs_readable ||= @@max_freqs.all?(&File.method(:readable?))
+				@@min_f ||= cpus.map { |x|
+					[File.split(x)[-1], File.join(x, 'cpufreq/scaling_max_freq'.freeze)]
+				}
 
-				if @@max_freqs_readable
-					@@max_freqs.map { |x| IO.read(x).to_i }
-				else
-					[]
-				end
+				h = {}
+				@@min_f.each { |id, file|
+					h.merge!(id => IO.read(file).to_i) if File.readable?(file)
+				}
+
+				h
+			end
+
+			##
+			# Returns the corresponding governor of each CPU.
+			#
+			# The return type is a Hash.
+			#
+			# For example:
+			#    LinuxStat::CPU.governor
+			#
+			#    => {"cpu0"=>"powersave", "cpu1"=>"powersave", "cpu2"=>"performance", "cpu3"=>"performance"}
+			#
+			# If the information isn't available, it will return an empty Hash.
+			def governor
+				@@scaling_g ||= cpus.map { |x|
+					[File.split(x)[-1], File.join(x, 'cpufreq/scaling_governor'.freeze)]
+				}
+
+				h = {}
+				@@scaling_g.each { |id, file|
+					h.merge!(id => IO.read(file).tap(&:strip!)) if File.readable?(file)
+				}
+
+				h
+			end
+
+			##
+			# Returns an array of governors for each CPU as a Hash.
+			#
+			# For example:
+			#    LinuxStat::CPU.available_governors
+			#
+			#    => {"cpu0"=>["performance", "powersave"], "cpu1"=>["performance", "powersave"], "cpu2"=>["performance", "powersave"], "cpu3"=>["performance", "powersave"]}
+			#
+			# If the information isn't available, it will return an empty Hash.
+			def available_governors
+				@@scaling_av_g ||= cpus.map { |x|
+					[File.split(x)[-1], File.join(x, 'cpufreq/scaling_available_governors'.freeze)]
+				}
+
+				h = {}
+				@@scaling_av_g.each { |id, file|
+					h.merge!(id => IO.read(file).split.each(&:strip!)) if File.readable?(file)
+				}
+
+				h
 			end
 
 			alias usages stat
@@ -129,15 +302,23 @@ module LinuxStat
 
 			private
 			def cpuinfo
-				File.readable?('/proc/cpuinfo') ? IO.readlines('/proc/cpuinfo') : []
+				File.readable?('/proc/cpuinfo') ? IO.readlines('/proc/cpuinfo').freeze : [].freeze
 			end
 
 			def stat?
 				@@stat_readable ||= File.readable?('/proc/stat')
 			end
 
-			def ticks_to_ms
-				@@ms ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# Just to avoid duplicate calculations
+			# ticks to ms times 5
+			# If the ticks is 100, it will return 0.05
+			def ticks_to_ms_t5
+				@@sc_clk_tck ||= LinuxStat::Sysconf.sc_clk_tck.to_i
+				@@ms_t5 ||= 1.0 / (@@sc_clk_tck < 1 ? 100 : @@sc_clk_tck) * 5
+			end
+
+			def cpus
+				@@all_cpu = Dir["/sys/devices/system/cpu/cpu[0-9]*/"].sort!.freeze
 			end
 		end
 	end

data/lib/linux_stat/filesystem.rb

@@ -2,7 +2,7 @@ module LinuxStat
 	module Filesystem
 		class << self
 			##
-			# = stat(fs = '/')
+			# = stat(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -16,7 +16,7 @@ module LinuxStat
 			#    {:total=>119981191168, :free=>43155574784, :used=>76825616384, :available=>43155574784}
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def stat(fs = ?/.freeze)
+			def stat(fs = ?..freeze)
 				s = stat_raw(fs)
 				return {} if s.empty?
 				s.default = 0
@@ -29,14 +29,14 @@ module LinuxStat
 			end
 
 			##
-			# = total(fs = '/')
+			# = total(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
 			# It returns the total size of a given disk in bytes.
 			#
 			# If the stat can't be acquired, this method will return nil.
-			def total(fs = ?/.freeze)
+			def total(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -44,7 +44,7 @@ module LinuxStat
 			end
 
 			##
-			# = free(fs = '/')
+			# = free(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -55,7 +55,7 @@ module LinuxStat
 			# Free returns the size of free blocks.
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def free(fs = ?/.freeze)
+			def free(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -63,14 +63,14 @@ module LinuxStat
 			end
 
 			##
-			# = used(fs = '/')
+			# = used(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
 			# It returns the used space of a given disk in bytes.
 			#
 			# If the stat can't be acquired, this method will return nil.
-			def used(fs = ?/.freeze)
+			def used(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -78,7 +78,7 @@ module LinuxStat
 			end
 
 			##
-			# = available(fs = '/')
+			# = available(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -89,7 +89,7 @@ module LinuxStat
 			# Available returns the size of free blocks for unpriviledged users.
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def available(fs = ?/.freeze)
+			def available(fs = ?..freeze)
 				s = stat_raw(fs)
 				return nil if s.empty?
 				s.default = 0
@@ -97,7 +97,7 @@ module LinuxStat
 			end
 
 			##
-			# = stat_raw(fs = '/')
+			# = stat_raw(fs = '.')
 			#
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
@@ -105,7 +105,7 @@ module LinuxStat
 			#    {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10535967, :block_avail_unpriv=>10535967, :inodes=>58612160, :free_inodes=>56718550, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def stat_raw(fs = ?/.freeze)
+			def stat_raw(fs = ?..freeze)
 				LinuxStat::FS.stat(fs)
 			end
 		end

data/lib/linux_stat/kernel.rb

@@ -185,7 +185,7 @@ module LinuxStat
 
 			private
 			def splitted
-				@@string_splitted ||= string.split
+				@@string_splitted ||= string.split.freeze
 			end
 		end
 	end

data/lib/linux_stat/os.rb

@@ -121,7 +121,7 @@ module LinuxStat
 					hour: h,
 					minute: m,
 					second: s
-				}
+				}.freeze
 			end
 
 			private
@@ -143,7 +143,7 @@ module LinuxStat
 			end
 
 			def uptime_readable?
-				@@uptime_readable = File.readable?('/proc/uptime')
+				@@uptime_readable ||= File.readable?('/proc/uptime')
 			end
 		end
 	end