linux_stat 2.1.1 → 2.2.3

data/exe/linuxstat.rb

@@ -150,9 +150,9 @@ execute.sort.each do |c|
 		disp_meth = "#{meth}"
 		disp_meth.concat(arg ? "(#{param})" : "(#{param})")
 
-		time = Time.now
+		time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 		ret = arg ? e.send(meth, arg) : e.send(meth)
-		time2 = Time.now
+		time2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 		time = time2.-(time).*(1_000_000).round(3)
 
 		v = ret.inspect

data/ext/procfs/procfs.c

@@ -38,5 +38,6 @@ int Init_procfs() {
 
 	// stat
 	rb_define_module_function(_procfs, "ps_state", ps_state, 1) ;
+	rb_define_module_function(_procfs, "ps_times", ps_times, 1) ;
 	rb_define_module_function(_procfs, "ps_stat", ps_stat, 1) ;
 }

data/ext/procfs/stat.h

@@ -17,6 +17,27 @@ VALUE ps_state(VALUE obj, VALUE pid) {
 	return rb_str_new_cstr(_s) ;
 }
 
+VALUE ps_times(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/stat", _pid) ;
+
+	FILE *f = fopen(_path, "r") ;
+	if (!f) return Qnil ;
+
+	unsigned long utime, stime ;
+
+	char status = fscanf(f, "%*llu (%*[^)]%*[)] %*c %*d %*d %*d %*d %*d %*u %*lu %*lu %*lu %*lu %lu %lu", &utime, &stime) ;
+	fclose(f) ;
+
+	if (status != 2) return Qnil ;
+	double total_time = (utime + stime) / (float)sysconf(_SC_CLK_TCK);
+
+	return DBL2NUM(total_time) ;
+}
+
 VALUE ps_stat(VALUE obj, VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return rb_str_new_cstr("") ;

data/lib/linux_stat/battery.rb

@@ -105,11 +105,19 @@ module LinuxStat
 			#
 			# If the battery is not present or the information is not available, it will return nil.
 			def charge
-				@@charge_now_file ||= File.join(PATH, 'charge_now')
-				@@charge_full_file ||= File.join(PATH, 'charge_full')
+				@@charge_now_file ||= if File.readable?(File.join(PATH, 'charge_now'))
+					File.join(PATH, 'charge_now').freeze
+				elsif File.readable?(File.join(PATH, 'energy_now'))
+					File.join(PATH, 'energy_now').freeze
+				end
+
+				@@charge_full_file ||= if File.readable?(File.join(PATH, 'charge_full'))
+					File.join(PATH, 'charge_full').freeze
+				elsif File.readable?(File.join(PATH, 'energy_full'))
+					File.join(PATH, 'energy_full').freeze
+				end
 
-				@@charge_now_readable ||= File.readable?(@@charge_now_file) && File.readable?(@@charge_full_file)
-				return nil unless @@charge_now_readable
+				return nil unless @@charge_now_file && @@charge_full_file
 
 				charge_now = IO.read(@@charge_now_file).to_i
 				charge_full = IO.read(@@charge_full_file).to_i
@@ -215,7 +223,16 @@ module LinuxStat
 
 					# charge now
 					cn_f = File.join(x, 'charge_now'.freeze).freeze
-					charge_now = File.readable?(cn_f) ? IO.read(cn_f).to_i.fdiv(1_000_000) : nil
+					charge_now = if File.readable?(cn_f)
+						IO.read(cn_f).to_i.fdiv(1_000_000)
+					else
+						en_f = File.join(x, 'energy_now'.freeze)
+						if File.readable?(en_f)
+							IO.read(en_f) .to_i.fdiv(1_000_000)
+						else
+							nil
+						end
+					end
 
 					# voltage min design
 					vmd_f = File.join(x, 'voltage_min_design'.freeze).freeze
@@ -227,7 +244,16 @@ module LinuxStat
 
 					# charge full
 					cf_f = File.join(x, 'charge_full'.freeze).freeze
-					charge_full = File.readable?(cf_f) ? IO.read(cf_f).to_i.fdiv(1_000_000) : nil
+					charge_full = if File.readable?(cf_f)
+						IO.read(cf_f).to_i.fdiv(1_000_000)
+					else
+						ef_f = File.join(x, 'energy_full'.freeze)
+						if File.readable?(ef_f)
+							IO.read(ef_f).to_i.fdiv(1_000_000)
+						else
+							nil
+						end
+					end
 
 					# status
 					s_f = File.join(x, 'status'.freeze).freeze

data/lib/linux_stat/os.rb

@@ -7,7 +7,11 @@ module LinuxStat
 			# Reads /etc/os-release and returns a Hash. For example:
 			#    LinuxStat::OS.os_release
 			#
-			#    => {:NAME=>"Arch Linux", :PRETTY_NAME=>"Arch Linux", :ID=>"arch", :BUILD_ID=>"rolling", :ANSI_COLOR=>"38;2;23;147;209", :HOME_URL=>"https://www.archlinux.org/", :DOCUMENTATION_URL=>"https://wiki.archlinux.org/", :SUPPORT_URL=>"https://bbs.archlinux.org/", :BUG_REPORT_URL=>"https://bugs.archlinux.org/", :LOGO=>"archlinux"}
+			#    => {:NAME=>"Arch Linux", :PRETTY_NAME=>"Arch Linux", :ID=>"arch", :BUILD_ID=>"rolling",
+			# :ANSI_COLOR=>"38;2;23;147;209", :HOME_URL=>"https://www.archlinux.org/",
+			# :DOCUMENTATION_URL=>"https://wiki.archlinux.org/",
+			# :SUPPORT_URL=>"https://bbs.archlinux.org/", :BUG_REPORT_URL=>"https://bugs.archlinux.org/",
+			# :LOGO=>"archlinux"}
 			#
 			# If the info isn't available, it will return an empty Hash.
 			#
@@ -127,7 +131,7 @@ module LinuxStat
 			#
 			# The return type is strictly Integer and doesn't fail.
 			def bits
-				@@bits ||= if RbConfig::CONFIG['host_cpu'].end_with?('64') || RUBY_PLATFORM.end_with?('64') || machine.end_with?('64')
+				@@bits ||= if machine.end_with?('64') || RbConfig::CONFIG['host_cpu'].end_with?('64') || RUBY_PLATFORM.end_with?('64')
 					64
 				else
 					32
@@ -138,7 +142,7 @@ module LinuxStat
 			# Reads /proc/uptime and returns the system uptime:
 			#    LinuxStat::OS.uptime
 			#
-			#    => {:hour=>10, :minute=>34, :second=>12.59}
+			#    => {:hour=>16, :minute=>10, :second=>11, :jiffy=>20}
 			#
 			# Using uptime is 10x slower than using uptime_i
 			#
@@ -151,12 +155,14 @@ module LinuxStat
 
 				h = uptime_i / 3600
 				m = uptime_i % 3600 / 60
-				s = _uptime.%(60).round(2)
+				s = uptime_i.%(60)
+				j = _uptime.-(uptime_i) * 100
 
 				{
 					hour: h,
 					minute: m,
-					second: s
+					second: s,
+					jiffy: j.to_i
 				}
 			end
 

data/lib/linux_stat/prettify_bytes.rb

@@ -7,6 +7,28 @@ module LinuxStat
 	# 4. kiB, MiB, GiB, TiB, PiB, EiB, ZiB, YiB
 
 	module PrettifyBytes
+		# Kilo = Kilobyte (1000 - 1), and so on...
+		# 8.times { |x| puts 1000.**(x.next).to_s << '.00' }
+		KILO = 1000.00
+		MEGA = 1000000.00
+		GIGA = 1000000000.00
+		TERA = 1000000000000.00
+		PETA = 1000000000000000.00
+		EXA = 1000000000000000000.00
+		ZETTA = 1000000000000000000000.00
+		YOTTA = 1000000000000000000000000.00
+
+		# Binary suffixes
+		# 8.times { |x| puts 1024.**(x.next).to_s << '.00' }
+		KIBI = 1024.00
+		MEBI = 1048576.00
+		GIBI = 1073741824.00
+		TEBI = 1099511627776.00
+		PEBI = 1125899906842624.00
+		EXBI = 1152921504606846976.00
+		ZEBI = 1180591620717411303424.00
+		YOBI = 1208925819614629174706176.00
+
 		class << self
 			##
 			# Converts a number to decimal byte units and outputs with the metric prefix
@@ -24,12 +46,33 @@ module LinuxStat
 			#
 			# => "1.07 gigabytes"
 			def convert_decimal(n, precision: 2)
-				@@d_units ||= %W(#{''} kilo mega giga tera peta exa zetta)
-					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
-				unit = @@d_units.find { |x| n < x[1] } || ['yotta'.freeze, 10 ** 27]
-
-				converted = n.fdiv(unit[1] / 1000).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+				if n < KILO
+					"#{"%.#{precision}f" % n} byte#{?s.freeze if n != 1}"
+				elsif n < MEGA
+					n /= KILO
+					"#{"%.#{precision}f" % n} kilobyte#{?s.freeze if n != 1}"
+				elsif n < GIGA
+					n /= MEGA
+					"#{"%.#{precision}f" % n} megabyte#{?s.freeze if n != 1}"
+				elsif n < TERA
+					n /= GIGA
+					"#{"%.#{precision}f" % n} gigabyte#{?s.freeze if n != 1}"
+				elsif n < PETA
+					n /= TERA
+					"#{"%.#{precision}f" % n} terabyte#{?s.freeze if n != 1}"
+				elsif n < EXA
+					n /= PETA
+					"#{"%.#{precision}f" % n} petabyte#{?s.freeze if n != 1}"
+				elsif n < ZETTA
+					n /= EXA
+					"#{"%.#{precision}f" % n} exabyte#{?s.freeze if n != 1}"
+				elsif n < YOTTA
+					n /= ZETTA
+					"#{"%.#{precision}f" % n} zettabyte#{?s.freeze if n != 1}"
+				else
+					n /= YOTTA
+					"#{"%.#{precision}f" % n} yottabyte#{?s.freeze if n != 1}"
+				end
 			end
 
 			# Converts a number to binary byte units and outputs with the IEC prefix
@@ -47,12 +90,33 @@ module LinuxStat
 			#
 			# => "1.0 gibibyte"
 			def convert_binary(n, precision: 2)
-				@@b_units ||= %W(#{''} kibi mebi gibi tebi pebi exbi zebi)
-					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
-				unit = @@b_units.find { |x| n < x[1] } || ['yobi'.freeze, 10 ** 27]
-
-				converted = n.fdiv(unit[1] / 1024).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+				if n < KIBI
+					"#{"%.#{precision}f" % n} byte#{?s.freeze if n != 1}"
+				elsif n < MEBI
+					n /= KIBI
+					"#{"%.#{precision}f" % n} kibibyte#{?s.freeze if n != 1}"
+				elsif n < GIBI
+					n /= MEBI
+					"#{"%.#{precision}f" % n} mebibyte#{?s.freeze if n != 1}"
+				elsif n < TEBI
+					n /= GIBI
+					"#{"%.#{precision}f" % n} gibibyte#{?s.freeze if n != 1}"
+				elsif n < PEBI
+					n /= TEBI
+					"#{"%.#{precision}f" % n} tebibyte#{?s.freeze if n != 1}"
+				elsif n < EXBI
+					n /= PEBI
+					"#{"%.#{precision}f" % n} pebibyte#{?s.freeze if n != 1}"
+				elsif n < ZEBI
+					n /= EXBI
+					"#{"%.#{precision}f" % n} exbiyte#{?s.freeze if n != 1}"
+				elsif n < YOBI
+					n /= ZEBI
+					"#{"%.#{precision}f" % n} zebibyte#{?s.freeze if n != 1}"
+				else
+					n /= YOBI
+					"#{"%.#{precision}f" % n} yobibyte#{?s.freeze if n != 1}"
+				end
 			end
 
 			# Converts a number to decimal byte units
@@ -70,12 +134,33 @@ module LinuxStat
 			#
 			# => "1.07 GB"
 			def convert_short_decimal(n, precision: 2)
-				@@sd_units ||= %W(#{''} k M G T P E Z)
-					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
-				unit = @@sd_units.find { |x| n < x[1] } || [?Y.freeze, 10 ** 27]
-
-				converted = n.fdiv(unit[1] / 1000).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}B"
+				if n < KILO
+					"#{"%.#{precision}f" % n} B"
+				elsif n < MEGA
+					n /= KILO
+					"#{"%.#{precision}f" % n} kB"
+				elsif n < GIGA
+					n /= MEGA
+					"#{"%.#{precision}f" % n} MB"
+				elsif n < TERA
+					n /= GIGA
+					"#{"%.#{precision}f" % n} GB"
+				elsif n < PETA
+					n /= TERA
+					"#{"%.#{precision}f" % n} TB"
+				elsif n < EXA
+					n /= PETA
+					"#{"%.#{precision}f" % n} PB"
+				elsif n < ZETTA
+					n /= EXA
+					"#{"%.#{precision}f" % n} EB"
+				elsif n < YOTTA
+					n /= ZETTA
+					"#{"%.#{precision}f" % n} ZB"
+				else
+					n /= YOTTA
+					"#{"%.#{precision}f" % n} YB"
+				end
 			end
 
 			##
@@ -95,19 +180,33 @@ module LinuxStat
 			#
 			# => "1.0 GiB"
 			def convert_short_binary(n, precision: 2)
-				return "#{pad_left(n, precision)} B" if n < 1024
-
-				@@sb_units ||= %W(#{''} K M G T P E Z)
-					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
-				unit = @@sb_units.find { |x| n < x[1] } || [?Y.freeze, 1024 ** 9]
-
-				converted = n.fdiv(unit[1] / 1024).round(2)
-				"#{pad_left(converted, precision)} #{unit[0]}iB"
-			end
-
-			private
-			def pad_left(n, mantissa_length = 2)
-				sprintf("%.#{mantissa_length}f".freeze, n)
+				if n < KIBI
+					"#{"%.#{precision}f" % n} B"
+				elsif n < MEBI
+					n /= KIBI
+					"#{"%.#{precision}f" % n} KiB"
+				elsif n < GIBI
+					n /= MEBI
+					"#{"%.#{precision}f" % n} MiB"
+				elsif n < TEBI
+					n /= GIBI
+					"#{"%.#{precision}f" % n} GiB"
+				elsif n < PEBI
+					n /= TEBI
+					"#{"%.#{precision}f" % n} TiB"
+				elsif n < EXBI
+					n /= PEBI
+					"#{"%.#{precision}f" % n} PiB"
+				elsif n < ZEBI
+					n /= EXBI
+					"#{"%.#{precision}f" % n} EiB"
+				elsif n < YOBI
+					n /= ZEBI
+					"#{"%.#{precision}f" % n} ZiB"
+				else
+					n /= YOBI
+					"#{"%.#{precision}f" % n} YiB"
+				end
 			end
 		end
 	end

data/lib/linux_stat/process_info.rb

@@ -283,7 +283,7 @@ module LinuxStat
 				uptime = LS::ProcFS.uptime_f
 				return {} unless uptime && !stat.empty?
 
-				utime, stime, starttime = *stat.values_at(11, 12, 19).map(&:to_f)
+				utime, stime, starttime = *stat.values_at(10, 11, 18).map(&:to_f)
 				uptime *= ticks
 
 				total_time = utime + stime
@@ -295,14 +295,14 @@ module LinuxStat
 				uptime = LS::ProcFS.uptime_f
 				return {} unless uptime && !stat.empty?
 
-				utime2, stime2, starttime2 = *stat.values_at(11, 12, 19).map(&:to_f)
+				utime2, stime2, starttime2 = *stat.values_at(10, 11, 18).map(&:to_f)
 				uptime *= ticks
 
 				total_time2 = utime2 + stime2
 				idle2 = uptime - starttime2 - total_time2
 
 				totald = idle2.+(total_time2).-(idle1 + total_time)
-				cpu_u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
+				cpu_u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(LinuxStat::CPU.count)
 
 				{
 					cpu_usage: cpu_u > 100 ? 100.0 : cpu_u.round(2),
@@ -338,32 +338,10 @@ module LinuxStat
 			#
 			# This method is more efficient than running LinuxStat::ProcessInfo.cpu_stat()
 			def cpu_usage(pid: $$, sleep: ticks_to_ms_t5)
-				ticks = get_ticks
-				stat = LinuxStat::ProcFS.ps_stat(pid)
-				uptime = LS::ProcFS.uptime_f
-				return nil unless uptime && !stat.empty?
-
-				utime, stime, starttime = *stat.values_at(10, 11, 18).map(&:to_f)
-				uptime *= ticks
-
-				total_time = utime + stime
-				idle1 = uptime - starttime - total_time
-
-				sleep(sleep)
-
-				stat = LinuxStat::ProcFS.ps_stat(pid)
-				uptime = LS::ProcFS.uptime_f
-				return nil unless uptime && !stat.empty?
-
-				utime2, stime2, starttime2 = *stat.values_at(10, 11, 18).map(&:to_f)
-				uptime *= ticks
-
-				total_time2 = utime2 + stime2
-				idle2 = uptime - starttime2 - total_time2
-
-				totald = idle2.+(total_time2).-(idle1 + total_time)
+				u = cpu_usage_thread(pid, sleep)
+				return nil unless u
 
-				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
+				u /= LinuxStat::CPU.count
 				u > 100 ? 100.0 : u.round(2)
 			end
 
@@ -390,34 +368,10 @@ module LinuxStat
 			#
 			# But if the info isn't available, it will return nil.
 			def thread_usage(pid: $$, sleep: ticks_to_ms_t5)
-				ticks = get_ticks
-				stat = LinuxStat::ProcFS.ps_stat(pid)
-				uptime = LS::ProcFS.uptime_f
-				return nil unless uptime && !stat.empty?
-
-				utime, stime, starttime = *stat.values_at(10, 11, 18).map(&:to_f)
-				uptime *= ticks
-
-				total_time = utime + stime
-				idle1 = uptime - starttime - total_time
-
-				sleep(sleep)
-
-				stat = LinuxStat::ProcFS.ps_stat(pid)
-				uptime = LS::ProcFS.uptime_f
-				return nil unless uptime && !stat.empty?
-
-				utime2, stime2, starttime2 = *stat.values_at(10, 11, 18).map(&:to_f)
-				uptime *= ticks
-
-				total_time2 = utime2 + stime2
-				idle2 = uptime - starttime2 - total_time2
-
-				totald = idle2.+(total_time2).-(idle1 + total_time)
+				u = cpu_usage_thread(pid, sleep)
+				return nil unless u
 
-				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)
-
-				cpu_count_t100 = cpu_count * 100
+				cpu_count_t100 = LinuxStat::CPU.count * 100
 				u > cpu_count_t100 ? cpu_count_t100 : u.round(2)
 			end
 
@@ -567,7 +521,9 @@ module LinuxStat
 			def start_time(pid = $$)
 				# Getting two Time objects and dealing with floating point numbers
 				# Just to make sure the time goes monotonically
-				Time.at(start_time_epoch(pid))
+				_ste = start_time_epoch(pid)
+				return nil unless _ste
+				Time.at(_ste)
 			end
 
 			##
@@ -660,13 +616,10 @@ module LinuxStat
 			#
 			# Shows the CPU time used by the process.
 			#
-			# The return value is an Integer.
+			# The return value is a Float.
+			# But if the info isn't available, it will return nil.
 			def cpu_time(pid = $$)
-				times = LinuxStat::ProcFS.ps_stat(pid)
-				utime, stime, cutime, cstime = times[10], times[11], times[12], times[13]
-				return nil unless utime && stime && cutime && cstime
-
-				utime.+(stime).+(cutime).+(cstime) / get_ticks
+				LinuxStat::ProcFS.ps_times(pid)
 			end
 
 			##
@@ -674,19 +627,28 @@ module LinuxStat
 			#
 			# Shows the CPU time used by the process.
 			#
-			# The return value is a Hash.
+			# The return value is a Hash formatted like this:
+			#    LS::ProcessInfo.cpu_times($$)
+			#
+			#    => {:hour=>0, :minute=>39, :second=>12, :jiffy=>0.42}
+			#
+			# But if the info isn't available, it will return an empty Hash..
 			def cpu_times(pid = $$)
-				v = cpu_time(pid)
+				v = LinuxStat::ProcFS.ps_times(pid)
 				return {} unless v
 
-				hour = v / 3600
-				min = v % 3600 / 60
-				sec = v % 60
+				v_i = v.to_i
+
+				hour = v_i / 3600
+				min = v_i % 3600 / 60
+				sec = v_i % 60
+				jiffy = v.-(v_i) * 100
 
 				{
 					hour: hour,
 					minute: min,
-					second: sec
+					second: sec,
+					jiffy: jiffy.to_i
 				}
 			end
 
@@ -709,8 +671,33 @@ module LinuxStat
 				@@pagesize ||= LinuxStat::Sysconf.pagesize.to_i
 			end
 
-			def cpu_count
-				@@nprocessors_conf ||= LinuxStat::CPU.count
+			def cpu_usage_thread(pid, delay)
+				ticks = get_ticks
+				stat = LinuxStat::ProcFS.ps_stat(pid)
+				uptime = LS::ProcFS.uptime_f
+				return nil unless uptime && !stat.empty?
+
+				utime, stime, starttime = *stat.values_at(10, 11, 18).map(&:to_f)
+				uptime *= ticks
+
+				total_time = utime + stime
+				idle1 = uptime - starttime - total_time
+
+				sleep(delay)
+
+				stat = LinuxStat::ProcFS.ps_stat(pid)
+				uptime = LS::ProcFS.uptime_f
+				return nil unless uptime && !stat.empty?
+
+				utime2, stime2, starttime2 = *stat.values_at(10, 11, 18).map(&:to_f)
+				uptime *= ticks
+
+				total_time2 = utime2 + stime2
+				idle2 = uptime - starttime2 - total_time2
+
+				totald = idle2.+(total_time2).-(idle1 + total_time)
+
+				totald.-(idle2 - idle1).fdiv(totald).abs.*(100)
 			end
 		end
 	end