linux_stat 2.0.1 → 2.2.1

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

@@ -1,6 +1,9 @@
 VALUE ps_state(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return rb_str_new_cstr("") ;
+
 	char _path[22] ;
-	sprintf(_path, "/proc/%lu/stat", FIX2UINT(pid)) ;
+	sprintf(_path, "/proc/%d/stat", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
 	if (!f) return rb_str_new_cstr("") ;
@@ -14,9 +17,33 @@ 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("") ;
+
 	char _path[22] ;
-	sprintf(_path, "/proc/%lu/stat", FIX2UINT(pid)) ;
+	sprintf(_path, "/proc/%d/stat", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
 

data/ext/procfs/statm.h

@@ -1,13 +1,15 @@
 #define PAGESIZE sysconf(_SC_PAGESIZE)
 
 VALUE statm(VALUE obj, VALUE pid) {
-	char _path[22] ;
-	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+	VALUE hash = rb_hash_new() ;
 
-	FILE *f = fopen(_path, "r") ;
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return hash ;
 
-	VALUE hash = rb_hash_new() ;
+	char _path[22] ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
 
+	FILE *f = fopen(_path, "r") ;
 	if (!f) return hash ;
 
 	unsigned int _virtual, resident, shared ;
@@ -33,13 +35,15 @@ VALUE statm(VALUE obj, VALUE pid) {
 }
 
 VALUE statm_virtual(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
 	char _path[22] ;
-	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
-	VALUE hash = rb_hash_new() ;
+	if (!f) return Qnil ;
 
-	if (!f) return hash ;
 	unsigned int _virtual ;
 	char status = fscanf(f, "%u", &_virtual) ;
 	fclose(f) ;
@@ -49,13 +53,15 @@ VALUE statm_virtual(VALUE obj, VALUE pid) {
 }
 
 VALUE statm_resident(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
 	char _path[22] ;
-	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
-	VALUE hash = rb_hash_new() ;
+	if (!f) return Qnil ;
 
-	if (!f) return hash ;
 	unsigned int resident ;
 	char status = fscanf(f, "%*u %u", &resident) ;
 	fclose(f) ;
@@ -65,13 +71,15 @@ VALUE statm_resident(VALUE obj, VALUE pid) {
 }
 
 VALUE statm_shared(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
 	char _path[22] ;
-	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
-	VALUE hash = rb_hash_new() ;
+	if (!f) return Qnil ;
 
-	if (!f) return hash ;
 	unsigned int shared ;
 	char status = fscanf(f, "%*u %*u %u", &shared) ;
 	fclose(f) ;
@@ -81,11 +89,13 @@ VALUE statm_shared(VALUE obj, VALUE pid) {
 }
 
 VALUE statm_memory(VALUE obj, VALUE pid) {
+	int _pid = FIX2INT(pid) ;
+	if (_pid < 0) return Qnil ;
+
 	char _path[22] ;
-	sprintf(_path, "/proc/%lu/statm", FIX2UINT(pid)) ;
+	sprintf(_path, "/proc/%d/statm", _pid) ;
 
 	FILE *f = fopen(_path, "r") ;
-
 	if (!f) return Qnil ;
 
 	unsigned int resident, shared ;

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
@@ -178,7 +186,14 @@ module LinuxStat
 			# For example, a sample output can be like this (taken on a test system):
 			#
 			#    LinuxStat::Battery.devices_stat
-			#    => {:AC=>{:type=>"Mains", :online=>1}, :BAT0=>{:model=>"DELL CYMGM77", :manufacturer=>"Samsung SDI", :type=>"Battery", :status=>"Full", :capacity=>100, :voltage_min_design=>11.4, :charge_full_design=>3.684, :charge_full_design_wh=>42.0, :voltage_now=>12.558, :charge_now=>2.087, :charge_now_wh=>26.21, :charge_full_wh=>23.79, :charge_percentage=>100.0}, :hidpp_battery_0=>{:model=>"Wireless Keyboard", :manufacturer=>"Logitech", :type=>"Battery", :status=>"Discharging", :online=>1}}
+			#    => {:AC=>{:type=>"Mains", :online=>1},
+			# :BAT0=>{:model=>"DELL CYMGM77", :manufacturer=>"Samsung SDI",
+			# :type=>"Battery", :status=>"Full", :capacity=>100, :voltage_min_design=>11.4,
+			# :charge_full_design=>3.684, :charge_full_design_wh=>42.0,
+			# :voltage_now=>12.558, :charge_now=>2.087, :charge_now_wh=>26.21,
+			# :charge_full_wh=>23.79, :charge_percentage=>100.0},
+			# :hidpp_battery_0=>{:model=>"Wireless Keyboard", :manufacturer=>"Logitech",
+			# :type=>"Battery", :status=>"Discharging", :online=>1}}
 			#
 			# If you need info about lots of batteries, use this method.
 			# If the informations are not available, it will return empty Hash for each devices.
@@ -208,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
@@ -220,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.%(3600).%(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/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
+				u = cpu_usage_thread(pid, sleep)
+				return nil unless u
 
-				totald = idle2.+(total_time2).-(idle1 + total_time)
-
-				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
+				u = cpu_usage_thread(pid, sleep)
+				return nil unless u
 
-				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 = 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
 
@@ -655,6 +609,47 @@ module LinuxStat
 				LinuxStat::Nproc.count_cpu_for_pid(pid)
 			end
 
+			##
+			# = def cpu_times_i(pid = $$)
+			#
+			# Shows the CPU time used by the process.
+			#
+			# The return value is a Float.
+			# But if the info isn't available, it will return nil.
+			def cpu_time(pid = $$)
+				LinuxStat::ProcFS.ps_times(pid)
+			end
+
+			##
+			# = def cpu_times(pid = $$)
+			#
+			# Shows the CPU time used by the process.
+			#
+			# 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 = LinuxStat::ProcFS.ps_times(pid)
+				return {} unless v
+
+				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,
+					jiffy: jiffy.to_i
+				}
+			end
+
 			alias count_cpu nproc
 
 			private
@@ -674,8 +669,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