linux_stat 0.7.0 → 0.9.0

data/exe/linuxstat.rb

@@ -7,6 +7,46 @@ rescue LoadError
 	abort "The Gem needs to be installed before this test can be run!"
 end
 
+# Gradient colour to strings
+class String
+	def colourize(colour = 1, flip: false)
+		colours, line_length = [], -1
+		temp = ''
+
+		each_line do |c|
+			n, i = c.length, -1
+
+			if line_length != n
+				step, line_length = 255.0./(n), n
+				colours.clear
+
+				while (i += 1) < n
+					l = i.*(step)
+					colours.<<(
+						case colour
+							when 0 then [ l.*(2).to_i.clamp(0, 255), l.to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255) ]
+							when 1 then [ 255, 255.-(l).to_i.clamp(0, 255), l.to_i.clamp(0, 255) ]
+							when 2 then [ l.to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), l.to_i.clamp(0, 255) ]
+							when 3 then [ l.*(2).to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), 100.+(l / 2).to_i.clamp(0, 255) ]
+							when 4 then [ 30, 255.-(l / 2).to_i.clamp(0, 255), 110.+(l / 2).to_i.clamp(0, 255) ]
+							when 5 then [ 255.-(l * 2).to_i.clamp(0, 255), l.to_i.clamp(0, 255), 200 ]
+							when 6 then [ 50.+(255 - l).to_i.clamp(0, 255), 255.-(l / 2).to_i.clamp(0, 255), (l * 2).to_i.clamp(0, 255) ]
+							else [ l.*(2).to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), 100.+(l / 2).to_i.clamp(0, 255) ]
+						end
+					)
+				end
+
+				colours.reverse! if flip
+			end
+
+			i = -1
+			temp.concat "\e[38;2;#{colours[i][0]};#{colours[i][1]};#{colours[i][2]}m#{c[i]}" while (i += 1) < n
+		end
+
+		temp << "\e[0m".freeze
+	end
+end
+
 # Check which conflicting argument (e.g., `-md -html` together) is passed last
 # Always use the last argument
 conflicting, hash = [
@@ -36,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}")
@@ -54,7 +100,6 @@ execute.sort.each do |c|
 	next if e.class != Module && e.class != Class
 
 	meths = e.methods(false).sort
-	next if meths.any? { |a| e.method(a).arity > 0 }
 
 	if meths.length > 0
 		if MARKDOWN
@@ -67,20 +112,83 @@ execute.sort.each do |c|
 	end
 
 	meths.each do |meth|
+		arg = nil
+		params = e.method(meth).parameters
+
+		param = ''
+
+		params.each do |p|
+			case p[0]
+				when :opt
+					param << "#{p[1]}, "
+				when :key
+					param << "#{p[1]}:, "
+				when :req
+					param << "#{p[1] || 'arg'}, "
+			end
+		end
+
+		param.delete_suffix!(", ")
+
+		if e.method(meth).arity > 0
+			if c == :PrettifyBytes
+				arg = rand(10 ** 15)
+			elsif c == :FS
+				arg = '/'
+			else
+				next
+			end
+		end
+
+		disp_meth = "#{meth}"
+		disp_meth.concat(arg ? "(#{param} = #{arg.inspect})" : "(#{param})")
+
 		time = Time.now
-		v = 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_ret = '', '', ''
+
+		unless source.empty?
+			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(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 "#{e}.#{meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
 		elsif HTML
-			puts "#{e}.#{meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{src_ret}#{e}.#{disp_meth}\n=> #{dis}"
 		else
-			puts "\e[1;38;2;80;80;255m#{e}.#{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,8 +1,15 @@
 #include <sys/statvfs.h>
 #include "ruby.h"
 
-#pragma GCC optimize ("O3")
-#pragma clang optimize on
+#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 statfs(VALUE obj, VALUE dir) {
 	struct statvfs buf ;

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,8 +1,15 @@
 #include <unistd.h>
 #include "ruby.h"
 
-#pragma GCC optimize ("O3")
-#pragma clang optimize on
+#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 getTick(VALUE obj) {
 	return INT2FIX(sysconf(_SC_CLK_TCK)) ;
@@ -40,6 +47,22 @@ static VALUE getPosixVersion(VALUE obj) {
 	return INT2FIX(sysconf(_SC_VERSION)) ;
 }
 
+static VALUE getLineMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_LINE_MAX)) ;
+}
+
+static VALUE getExprNestMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_EXPR_NEST_MAX)) ;
+}
+
+static VALUE getProcessorConfigured(VALUE obj) {
+	return INT2FIX(sysconf(_SC_NPROCESSORS_CONF)) ;
+}
+
+static VALUE getProcessorOnline(VALUE obj) {
+	return INT2FIX(sysconf(_SC_NPROCESSORS_ONLN)) ;
+}
+
 static VALUE getUser(VALUE obj) {
 	char *name = getlogin() ;
 	return name ? rb_str_new_cstr(name) : rb_str_new_cstr("") ;
@@ -70,6 +93,11 @@ void Init_sysconf() {
 	rb_define_module_function(_sysconf, "stream_max", getStreamMax, 0) ;
 	rb_define_module_function(_sysconf, "tty_name_max", getTTYNameMax, 0) ;
 	rb_define_module_function(_sysconf, "posix_version", getPosixVersion, 0) ;
+	rb_define_module_function(_sysconf, "line_max", getLineMax, 0) ;
+	rb_define_module_function(_sysconf, "expr_nest_max", getExprNestMax, 0) ;
+
+	rb_define_module_function(_sysconf, "processor_online", getProcessorOnline, 0) ;
+	rb_define_module_function(_sysconf, "processor_configured", getProcessorConfigured, 0) ;
 
 	rb_define_module_function(_sysconf, "get_uid", getUID, 0) ;
 	rb_define_module_function(_sysconf, "get_gid", getGID, 0) ;

data/ext/utsname/utsname.c

@@ -1,39 +1,51 @@
 #include <sys/utsname.h>
 #include "ruby.h"
 
-#pragma GCC optimize ("O3")
-#pragma clang optimize on
+#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 struct utsname buf ;
-static short status ;
+
+static char *sysname = "", *nodename = "" ;
+static char *release = "", *version = "", *machine = "" ;
 
 void init_buf() {
-	status = uname(&buf) ;
+	short status = uname(&buf) ;
+
+	if (status > -1) {
+		sysname = buf.sysname ;
+		nodename = buf.nodename ;
+		release = buf.release ;
+		version = buf.version ;
+		machine = buf.machine ;
+	}
 }
 
 static VALUE getSysname(VALUE obj) {
-	VALUE sysname = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.sysname) ;
-	return sysname ;
+	return rb_str_new_cstr(sysname) ;
 }
 
 static VALUE getNodename(VALUE obj) {
-	VALUE nodename = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.nodename) ;
-	return nodename ;
+	return rb_str_new_cstr(nodename) ;
 }
 
 static VALUE getRelease(VALUE obj) {
-	VALUE release = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.release) ;
-	return release ;
+	return rb_str_new_cstr(release) ;
 }
 
 static VALUE getVersion(VALUE obj) {
-	VALUE version = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.version) ;
-	return version ;
+	return rb_str_new_cstr(version) ;
 }
 
 static VALUE getMachine(VALUE obj) {
-	VALUE machine = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.machine) ;
-	return machine ;
+	return rb_str_new_cstr(machine) ;
 }
 
 void Init_utsname() {

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

@@ -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,7 +60,7 @@ 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)
@@ -72,16 +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 threads.
+			# Returns the total number of CPU available for the sysetm.
 			#
-			# If the information isn't available, it will return 0.
+			# It returns an Integer.
+			#
+			# If the information isn't available, it will return an empty Array.
 			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 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 online
+				@@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)
+				}
+
+				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 +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.
+			#
+			# For example:
+			#    LinuxStat::CPU.max_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 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 +258,22 @@ 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
+				@@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