linux_stat 0.8.0 → 0.9.0

data/exe/linuxstat.rb

@@ -76,17 +76,23 @@ MARKDOWN, HTML = hash[:markdown], hash[:html]
 
 # Print time each method takes unless --no-time or -nt option is passed
 PRINT_TIME = (MARKDOWN || HTML) ? false : !ARGV.any? { |x| x[/^\-\-no-time$/] || x[/^\-nt$/] }
-
-%w(--markdown -md --no-time -nt --html -html).each(&ARGV.method(:delete))
+PRINT_TYPE = ARGV.any? { |x| x[/^\-(\-show\-type|t)$/] }
+%w(--markdown -md --no-time -nt --html -html --show-type -t).each(&ARGV.method(:delete))
 
 # Run only desired classes / modules
 constants = LinuxStat.constants
 
+# Modules to delete from documentation and testing
+%i(
+	Nproc
+).each(&constants.method(:delete))
+
 execute = constants.map(&:downcase).map.with_index { |x, i|
 	constants[i] if ARGV.find { |y| y.downcase.to_sym == x }
 }.compact
 
 execute.replace(constants) if execute.empty?
+HEXAGONS = %W(\u2b22 \u2b23 \u2B53 \u2B1F)
 
 execute.sort.each do |c|
 	e = eval("LinuxStat::#{c}")
@@ -138,36 +144,51 @@ execute.sort.each do |c|
 		disp_meth.concat(arg ? "(#{param} = #{arg.inspect})" : "(#{param})")
 
 		time = Time.now
-		v = arg ? e.send(meth, arg) : e.send(meth)
+		ret = arg ? e.send(meth, arg) : e.send(meth)
 		time2 = Time.now
 		time = time2.-(time).*(1_000_000).round(3)
 
-		v = v.inspect
+		v = ret.inspect
 		dis = v.length > 253 ? v[0..250].strip + '...'.freeze : v
 
 		source = e.singleton_method(meth).source_location.to_a
-		src, src_meth = '', ''
+		src, src_meth, src_ret = '', '', ''
 
 		unless source.empty?
-			src << " File: #{File.split(source[0])[-1]} | Line: #{source[1]}\n"
-			src_meth << " Definition: #{IO.foreach(source[0]).first(source[1])[-1].strip}\n"
+			src << " File:\t\t#{File.split(source[0])[-1]} | Line: #{source[1]}\n"
+			src_meth << " Definition:\t#{IO.foreach(source[0]).first(source[1])[-1].strip}\n"
+
+			src_ret << " Returns:\t" << case ret
+				when Array then 'Array | Empty Array'
+				when Complex then 'Complex | nil'
+				when Float then 'Float | nil'
+				when Hash then 'Hash | Empty Hash'
+				when Integer then 'Integer | nil'
+				when Rational then 'Rational | nil'
+				when String then "String | (Frozen) Empty String"
+				when Time then 'Time | nil'
+				when true, false then 'True or False | nil'
+				when nil then 'nil'
+				else ''
+			end << ?\n.freeze if PRINT_TYPE
 
 			if MARKDOWN || HTML
 				src.prepend('#'.freeze)
 				src_meth.prepend('#'.freeze)
+				src_ret.prepend(?#.freeze) if PRINT_TYPE
 			else
-				src.prepend(?\u2B23.freeze)
-				src_meth.prepend(?\u2B23.freeze)
+				src.prepend(HEXAGONS.rotate![0].freeze)
+				src_meth.prepend(HEXAGONS.rotate![0].freeze)
+				src_ret.prepend(HEXAGONS.rotate![0].freeze) if PRINT_TYPE
 			end
 		end
 
-
 		if MARKDOWN
-			puts "#{src}#{src_meth}#{e}.#{disp_meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
 		elsif HTML
-			puts "#{src}#{src_meth}#{e}.#{disp_meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
 		else
-			puts "\e[1m#{src.colourize}\e[1m#{src_meth.colourize(4)}\e[0m\e[1;38;2;80;80;255m#{e}.#{disp_meth}\e[0m\n=> #{dis}"
+			puts "\e[1m#{src.colourize}\e[1m#{src_meth.colourize(6)}\e[1m#{src_ret.colourize(1)}\e[0m\e[1;38;2;80;80;255m#{e}.#{disp_meth}\e[0m\n=> #{dis}"
 		end
 
 		puts( "(" +

data/ext/fs_stat/fs_stat.c

@@ -1,12 +1,14 @@
 #include <sys/statvfs.h>
 #include "ruby.h"
 
-#ifdef __GNUC__
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 	#pragma GCC optimize ("O3")
 	#pragma GCC diagnostic warning "-Wall"
-#elif __clang__
+#elif defined(__clang__)
 	#pragma clang optimize on
 	#pragma clang diagnostic warning "-Wall"
+#elif defined(__INTEL_COMPILER)
+	#pragma intel optimization_level 3
 #endif
 
 static VALUE statfs(VALUE obj, VALUE dir) {

data/ext/nproc/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+
+unless have_const('linux') || RbConfig::CONFIG['arch'].to_s[/linux/]
+	abort('Platform is not linux')
+end
+
+unless have_header('sched.h') && have_header('ruby.h')
+	abort('Missing header')
+end
+
+create_makefile 'linux_stat/nproc'

data/ext/nproc/nproc.c

@@ -0,0 +1,31 @@
+#ifndef _GNU_SOURCE
+	#define _GNU_SOURCE
+#endif
+
+#include <sched.h>
+#include "ruby.h"
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
+	#pragma GCC optimize ("O3")
+	#pragma GCC diagnostic warning "-Wall"
+#elif defined(__clang__)
+	#pragma clang optimize on
+	#pragma clang diagnostic warning "-Wall"
+#elif defined(__INTEL_COMPILER)
+	#pragma intel optimization_level 3
+#endif
+
+static VALUE count_cpu_for_pid(VALUE obj, VALUE pid) {
+	cpu_set_t set ;
+	CPU_ZERO(&set) ;
+	short int stat = sched_getaffinity(FIX2INT(pid), sizeof(set), &set) ;
+
+	if (stat < 0) return Qnil ;
+	return INT2FIX(CPU_COUNT(&set)) ;
+}
+
+void Init_nproc() {
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _nproc = rb_define_module_under(_linux_stat, "Nproc") ;
+	rb_define_module_function(_nproc, "count_cpu_for_pid", count_cpu_for_pid, 1) ;
+}

data/ext/sysconf/sysconf.c

@@ -1,12 +1,14 @@
 #include <unistd.h>
 #include "ruby.h"
 
-#ifdef __GNUC__
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 	#pragma GCC optimize ("O3")
 	#pragma GCC diagnostic warning "-Wall"
-#elif __clang__
+#elif defined(__clang__)
 	#pragma clang optimize on
 	#pragma clang diagnostic warning "-Wall"
+#elif defined(__INTEL_COMPILER)
+	#pragma intel optimization_level 3
 #endif
 
 static VALUE getTick(VALUE obj) {
@@ -53,11 +55,11 @@ static VALUE getExprNestMax(VALUE obj) {
 	return INT2FIX(sysconf(_SC_EXPR_NEST_MAX)) ;
 }
 
-VALUE getProcessorConfigured(VALUE obj) {
+static VALUE getProcessorConfigured(VALUE obj) {
 	return INT2FIX(sysconf(_SC_NPROCESSORS_CONF)) ;
 }
 
-VALUE getProcessorOnline(VALUE obj) {
+static VALUE getProcessorOnline(VALUE obj) {
 	return INT2FIX(sysconf(_SC_NPROCESSORS_ONLN)) ;
 }
 

data/ext/utsname/utsname.c

@@ -1,12 +1,14 @@
 #include <sys/utsname.h>
 #include "ruby.h"
 
-#ifdef __GNUC__
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 	#pragma GCC optimize ("O3")
 	#pragma GCC diagnostic warning "-Wall"
-#elif __clang__
+#elif defined(__clang__)
 	#pragma clang optimize on
 	#pragma clang diagnostic warning "-Wall"
+#elif defined(__INTEL_COMPILER)
+	#pragma intel optimization_level 3
 #endif
 
 static struct utsname buf ;

data/lib/linux_stat.rb

@@ -23,7 +23,6 @@ require 'linux_stat/prettify_bytes'
 # But might be required by other module functions in "Dependent Modules" section
 require "linux_stat/battery"
 require "linux_stat/bios"
-require "linux_stat/cpu"
 require "linux_stat/memory"
 require "linux_stat/net"
 require "linux_stat/process"
@@ -32,6 +31,10 @@ require "linux_stat/swap"
 # Dependent Modules
 # Modules that can have reverse dependency
 
+# LinuxStat::CPU.nproc dependent modules
+require "linux_stat/cpu"
+require "linux_stat/nproc"
+
 # LinuxStat::Uname dependent modules
 require 'linux_stat/utsname'
 require "linux_stat/os"
@@ -46,3 +49,6 @@ require "linux_stat/sysconf"
 require "linux_stat/kernel"
 require 'linux_stat/user'
 require "linux_stat/process_info"
+
+# A short alias to LinuxStat
+LS = LinuxStat

data/lib/linux_stat/battery.rb

@@ -98,12 +98,25 @@ module LinuxStat
 			#
 			# If the battery is not present or the information is not available, it will return nil.
 			def charge
-				return nil unless charge_now_readable?
-				charge_now = IO.read(File.join(PATH, 'charge_now')).to_i
-				charge_full = IO.read(File.join(PATH, 'charge_full')).to_i
+				@@charge_now_file ||= File.join(PATH, 'charge_now')
+				@@charge_full_file ||= File.join(PATH, 'charge_full')
+
+				@@charge_now_readable ||= File.readable?(@@charge_now_file) && File.readable?(@@charge_full_file)
+				return nil unless @@charge_now_readable
+
+				charge_now = IO.read(@@charge_now_file).to_i
+				charge_full = IO.read(@@charge_full_file).to_i
 
 				percentage = charge_now.*(100).fdiv(charge_full)
-				percentage = percentage > 100 ? 100.0 : percentage < 0 ? 0.0 : percentage
+				percentage > 100 ? 100.0 : percentage < 0 ? 0.0 : percentage
+			end
+
+			def voltage_now
+				@@voltage_file ||= File.join(PATH, 'voltage_now'.freeze)
+				@@voltage_readable ||= File.readable?(@@voltage_file)
+				return nil unless @@voltage_readable
+
+				IO.read(@@voltage_file, 16).to_f.fdiv(1000000)
 			end
 
 			private
@@ -122,11 +135,6 @@ module LinuxStat
 			def status_readable?
 				@@status_readable ||= File.readable?(File.join(PATH, 'status'))
 			end
-
-			def charge_now_readable?
-				@@charge_now_readable ||= File.readable?(File.join(PATH, 'charge_now')) &&
-					File.readable?(File.join(PATH, 'charge_full'))
-			end
 		end
 	end
 end

data/lib/linux_stat/cpu.rb

@@ -14,16 +14,18 @@ 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_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 (hotplugging).
 				# I had crashes on Termux.
@@ -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
 
@@ -72,31 +72,63 @@ 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)
-				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 available for the sysetm.
+			#
+			# It returns an Integer.
+			#
+			# If the information isn't available, it will return an empty Array.
+			def count
+				@@cpu_count ||= LinuxStat::Sysconf.processor_configured
 			end
 
 			##
-			# Returns the total number of CPU threads online now.
+			# Returns the total number of CPU online in the sysetm.
 			#
-			# This value can change while a CPU is offline, due to kernel's hotplugging feature.
+			# 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 0.
+			# If the information isn't available, it will return an empty Array.
 			def online
-				# Let's rely on sysconf(_SC_NPROCESSORS_CONF), which is 100x faster than
-				# counting online cpu from /sys/devices/system/cpu
+				@@online_file ||= '/sys/devices/system/cpu/online'.freeze
+				@@online_readable ||= File.readable?(@@online_file)
+				return [] unless @@online_readable
+
+				ret = []
+				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)
+				}
 
-				LinuxStat::Sysconf.processor_configured
+				ret
 			end
 
 			##
-			# Returns the total number of CPU threads configured for the sysetm.
+			# Returns the total number of CPU offline in the sysetm.
 			#
-			# If the information isn't available, it will return 0.
-			def count
-				# Let's rely on sysconf(_SC_NPROCESSORS_ONLN), which is 100x faster than running:
-				# IO.read('/sys/devices/system/cpu/online')[-2].to_i + 1
+			# 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)
+				}
 
-				LinuxStat::Sysconf.processor_online
+				ret
 			end
 
 			##
@@ -110,33 +142,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.
 			#
-			# If the information isn't available, it will return an empty array.
+			# For example:
+			#    LinuxStat::CPU.cur_freq
+			#
+			#    => {"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 a Hash with max core frequencies corresponding to the CPUs.
+			#
+			# For example:
+			#    LinuxStat::CPU.min_freq
+			#
+			#    => {"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 an array with max core frequencies corresponding to the usages.
+			# Returns a Hash with max core frequencies corresponding to the CPUs.
 			#
-			# If the information isn't available, it will return an empty array.
+			# 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
@@ -144,7 +258,7 @@ 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?
@@ -157,6 +271,10 @@ module LinuxStat
 			def ticks_to_ms_t5
 				@@ms_t5 ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
 			end
+
+			def cpus
+				@@all_cpu = Dir["/sys/devices/system/cpu/cpu[0-9]*/"].sort!.freeze
+			end
 		end
 	end
 end