linux_stat 1.5.1 → 2.1.2

data/ext/sysinfo/sysinfo.c

@@ -1,5 +1,4 @@
 #include <sys/sysinfo.h>
-#include <inttypes.h>
 #include "ruby.h"
 
 #if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
@@ -15,8 +14,7 @@
 static struct sysinfo info ;
 
 VALUE totalram(VALUE obj) {
-	static struct sysinfo info ;
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.totalram) ;
@@ -25,7 +23,7 @@ VALUE totalram(VALUE obj) {
 }
 
 VALUE freeram(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.freeram) ;
@@ -34,7 +32,7 @@ VALUE freeram(VALUE obj) {
 }
 
 VALUE sharedram(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.sharedram) ;
@@ -43,7 +41,7 @@ VALUE sharedram(VALUE obj) {
 }
 
 VALUE bufferram(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.bufferram) ;
@@ -53,7 +51,7 @@ VALUE bufferram(VALUE obj) {
 
 VALUE totalswap(VALUE obj) {
 	static struct sysinfo info ;
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.totalswap) ;
@@ -62,7 +60,7 @@ VALUE totalswap(VALUE obj) {
 }
 
 VALUE freeswap(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.freeswap) ;
@@ -71,7 +69,7 @@ VALUE freeswap(VALUE obj) {
 }
 
 VALUE totalhigh(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.totalhigh) ;
@@ -80,7 +78,7 @@ VALUE totalhigh(VALUE obj) {
 }
 
 VALUE freehigh(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
 	VALUE _rb_v = ULL2NUM((unsigned long long) info.freehigh) ;
@@ -89,15 +87,15 @@ VALUE freehigh(VALUE obj) {
 }
 
 VALUE uptime(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if (status < 0) return Qnil ;
 
-	uint64_t v = info.uptime ;
+	unsigned long long v = info.uptime ;
 	return ULL2NUM((unsigned long long) v) ;
 }
 
 VALUE loads(VALUE obj) {
-	short status = sysinfo(&info) ;
+	char status = sysinfo(&info) ;
 	if(status < 0) return rb_ary_new() ;
 
 	long double load = 1.f / (1 << SI_LOAD_SHIFT) ;
@@ -113,6 +111,54 @@ VALUE loads(VALUE obj) {
 	) ;
 }
 
+// Some people may need this function, just keep it to not make unnecessary calls
+VALUE sysinfoStat(VALUE obj) {
+	char status = sysinfo(&info) ;
+	VALUE hash = rb_hash_new() ;
+	if (status < 0) return hash ;
+
+	unsigned long long mem_unit = info.mem_unit ;
+	VALUE _rb_mem_unit = ULL2NUM(mem_unit) ;
+
+	unsigned long long _totalram = info.totalram ;
+	unsigned long long _freeram = info.freeram ;
+	unsigned long long _sharedram = info.sharedram ;
+	unsigned long long _bufferram = info.bufferram ;
+	unsigned long long _totalswap = info.totalswap ;
+	unsigned long long _freeswap = info.freeswap ;
+	unsigned long long _totalhigh = info.totalhigh ;
+	unsigned long long _freehigh = info.freehigh ;
+	unsigned long long _uptime = info.uptime ;
+
+	long double load = 1.f / (1 << SI_LOAD_SHIFT) ;
+
+	float l_1 = info.loads[0] * load ;
+	float l_5 = info.loads[1] * load ;
+	float l_15 = info.loads[2] * load ;
+
+	VALUE loads = rb_ary_new_from_args(3,
+		rb_float_new(l_1),
+		rb_float_new(l_5),
+		rb_float_new(l_15)
+	) ;
+
+	VALUE mul = rb_intern("*") ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("totalram")), rb_funcallv_public(ULL2NUM(_totalram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("freeram")), rb_funcallv_public(ULL2NUM(_freeram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("sharedram")), rb_funcallv_public(ULL2NUM(_sharedram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("bufferram")), rb_funcallv_public(ULL2NUM(_bufferram), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("totalswap")), rb_funcallv_public(ULL2NUM(_totalswap), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("freeswap")), rb_funcallv_public(ULL2NUM(_freeswap), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("totalhigh")), rb_funcallv_public(ULL2NUM(_totalhigh), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("freehigh")), rb_funcallv_public(ULL2NUM(_freehigh), mul, 1, &_rb_mem_unit)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("uptime")), rb_funcallv_public(ULL2NUM(_uptime), mul, 1, &_rb_mem_unit)) ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("loads")), loads) ;
+
+	return hash ;
+}
+
 void Init_sysinfo() {
 	VALUE _linux_stat = rb_define_module("LinuxStat") ;
 	VALUE _sysinfo = rb_define_module_under(_linux_stat, "Sysinfo") ;
@@ -127,4 +173,5 @@ void Init_sysinfo() {
 	rb_define_module_function(_sysinfo, "freehigh", freehigh, 0) ;
 	rb_define_module_function(_sysinfo, "uptime", uptime, 0) ;
 	rb_define_module_function(_sysinfo, "loads", loads, 0) ;
+	rb_define_module_function(_sysinfo, "stat", sysinfoStat, 0) ;
 }

data/ext/utsname/utsname.c

@@ -17,7 +17,7 @@ static char *sysname = "", *nodename = "" ;
 static char *release = "", *version = "", *machine = "" ;
 
 void init_buf() {
-	short status = uname(&buf) ;
+	char status = uname(&buf) ;
 
 	if (status > -1) {
 		sysname = buf.sysname ;

data/lib/linux_stat.rb

@@ -25,13 +25,16 @@ require "linux_stat/battery"
 require "linux_stat/bios"
 require "linux_stat/net"
 require "linux_stat/pci"
-require "linux_stat/process"
 require "linux_stat/thermal"
 require "linux_stat/usb"
 
 # Dependent Modules
 # Modules that can have reverse dependency
 
+# LinuxStat::ProcFS dependent modules
+require "linux_stat/procfs"
+require "linux_stat/process"
+
 # LinuxStat::CPU.sysinfo dependent modules
 require "linux_stat/sysinfo"
 require "linux_stat/swap"

data/lib/linux_stat/battery.rb

@@ -178,7 +178,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.

data/lib/linux_stat/net.rb

@@ -30,7 +30,7 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				indices = find_index_of_bytes
 				data.reject! { |x| x.strip.start_with?('lo:') }
-				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map(&:sum)
+				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }
 
 				{
 					received: r,
@@ -48,7 +48,7 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				index = find_index_of_bytes[0]
 				data.reject! { |x| x.strip.start_with?('lo:') }
-				data.map { |x| x.split[index].to_i }.sum
+				data.map { |x| x.split[index].to_i }.reduce(:+)
 			end
 
 			##
@@ -61,7 +61,7 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				index = find_index_of_bytes[-1]
 				data.reject! { |x| x.strip.start_with?('lo:') }
-				data.map { |x| x.split[index].to_i }.sum
+				data.map { |x| x.split[index].to_i }.reduce(:+)
 			end
 
 			##
@@ -89,13 +89,13 @@ module LinuxStat
 				data = IO.readlines(DEV).drop(2)
 				indices = find_index_of_bytes
 				data.reject! { |x| x.strip.start_with?('lo:'.freeze) }
-				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map(&:sum)
+				r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }
 
 				sleep(interval)
 
 				data2 = IO.readlines(DEV).drop(2)
 				data2.reject! { |x| x.strip.start_with?('lo:'.freeze) }
-				r2, t2 = data2.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map(&:sum)
+				r2, t2 = data2.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }
 
 				# Measure the difference
 				dr, dt = r2.-(r).fdiv(interval), t2.-(t).fdiv(interval)

data/lib/linux_stat/os.rb

@@ -140,29 +140,46 @@ module LinuxStat
 			#
 			#    => {:hour=>10, :minute=>34, :second=>12.59}
 			#
+			# Using uptime is 10x slower than using uptime_i
+			#
 			# If the stat isn't available, an empty hash is returned.
 			def uptime
-				return {} unless uptime_readable?
+				_uptime = LinuxStat::ProcFS.uptime_f
+				return {} unless _uptime
 
-				uptime = IO.read('/proc/uptime'.freeze).to_f
-				uptime_i = uptime.to_i
+				uptime_i = _uptime.to_i
 
 				h = uptime_i / 3600
 				m = uptime_i % 3600 / 60
-				s = uptime.%(3600).%(60).round(2)
+				s = _uptime.%(60).round(2)
 
 				{
 					hour: h,
 					minute: m,
 					second: s
-				}.freeze
+				}
+			end
+
+			##
+			# Returns Float uptime of the system reported by /proc/uptime
+			#    LinuxStat::OS.uptime_f
+			#
+			#    => 28956.34
+			#
+			# The value is generally rounded to 2 decimal places.
+			#
+			# Using uptime_f is 10x slower than using uptime_i
+			#
+			# If the stat isn't available, nil is returned.
+			def uptime_f
+				LinuxStat::ProcFS.uptime_f
 			end
 
 			##
 			# Returns uptime of the system reported by LinuxStat::Sysinfo.uptime()
 			#    LinuxStat::OS.uptime_i
 			#
-			#    28956
+			#    => 28956
 			#
 			# If the stat isn't available, nil is returned.
 			def uptime_i
@@ -214,10 +231,6 @@ module LinuxStat
 					h.merge!( key.to_sym => value )
 				}
 			end
-
-			def uptime_readable?
-				@@uptime_readable ||= File.readable?('/proc/uptime')
-			end
 		end
 	end
 end

data/lib/linux_stat/process.rb

@@ -86,7 +86,7 @@ module LinuxStat
 
 					begin
 						h.merge!(x =>
-							case IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip
+							case LinuxStat::ProcFS.ps_state(x)
 								when ?S.freeze then :sleeping
 								when ?I.freeze then :idle
 								when ?Z.freeze then :zombie
@@ -110,11 +110,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def sleeping
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?S.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?S.freeze
 				}
 			end
 
@@ -123,11 +119,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def idle
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?I.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?I.freeze
 				}
 			end
 
@@ -136,11 +128,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def zombie
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?Z.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?Z.freeze
 				}
 			end
 
@@ -149,11 +137,7 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def running
 				list.select { |x|
-					begin
-						IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip == ?R.freeze
-					rescue StandardError
-						false
-					end
+					LinuxStat::ProcFS.ps_state(x) == ?R.freeze
 				}
 			end
 
@@ -162,14 +146,20 @@ module LinuxStat
 			# The return type is an Array of Integers.
 			def stopped
 				list.select { |x|
-					begin
-						v = IO.read("/proc/#{x}/stat").split(/(\(.*\))/)[-1][/\s.+?/].strip
-						v == ?T.freeze || v == ?t.freeze
-					rescue StandardError
-						false
-					end
+					v = LinuxStat::ProcFS.ps_state(x)
+					v == ?T.freeze || v == ?t.freeze
 				}
 			end
+
+			##
+			# Returns the last_pid of the system.
+			# It directly calls LS::ProcFS.last_pid
+			#
+			# The return value is Integer, but if the status
+			# isn't available, it will return nil
+			def last_pid
+				LinuxStat::ProcFS.last_pid
+			end
 		end
 	end
 end

data/lib/linux_stat/process_info.rb

@@ -149,20 +149,7 @@ module LinuxStat
 			#
 			# If the info isn't available it will return an empty Hash.
 			def mem_stat(pid = $$)
-				statm = "/proc/#{pid}/statm".freeze
-				return {} unless File.readable?(statm)
-
-				data = IO.read(statm).split
-
-				_rss_anon = (data[1] && data[2]) ? data[1].to_i.-(data[2].to_i).*(pagesize).fdiv(1000) : nil
-				_virtual_memory = data[0] ? data[0].to_i*(pagesize).fdiv(1000) : nil
-				_resident_memory = data[1] ? data[1].to_i.*(pagesize).fdiv(1000) : nil
-
-				{
-					memory: _rss_anon,
-					virtual_memory: _virtual_memory,
-					resident_memory: _resident_memory
-				}
+				LinuxStat::ProcFS.statm(pid)
 			end
 
 			##
@@ -182,11 +169,7 @@ module LinuxStat
 			#
 			# If the info isn't available it will return nil.
 			def memory(pid = $$)
-				file = "/proc/#{pid}/statm".freeze
-				return nil unless File.readable?(file)
-
-				data = IO.read(file).split
-				(data[1] && data[2]) ? data[1].to_i.-(data[2].to_i).*(pagesize).fdiv(1000) : nil
+				LinuxStat::ProcFS.statm_memory(pid) &.fdiv(1000)
 			end
 
 			##
@@ -207,11 +190,7 @@ module LinuxStat
 			#
 			# If the info isn't available it will return nil.
 			def virtual_memory(pid = $$)
-				file = "/proc/#{pid}/statm".freeze
-				return nil unless File.readable?(file)
-
-				_virtual_memory = IO.read(file).split[0]
-				_virtual_memory ? _virtual_memory.to_i.*(pagesize).fdiv(1000) : nil
+				LinuxStat::ProcFS.statm_virtual(pid) &.fdiv(1000)
 			end
 
 			##
@@ -226,17 +205,34 @@ module LinuxStat
 			# The value is in kilobytes.
 			#
 			# The output is an Integer. For example:
-			#    LinuxStat::ProcessInfo.cpu_stat
+			#    LinuxStat::ProcessInfo.resident_memory
 			#
 			#    => 13996.032
 			#
 			# If the info isn't available it will return nil.
 			def resident_memory(pid = $$)
-				file = "/proc/#{pid}/statm".freeze
-				return nil unless File.readable?(file)
+				LinuxStat::ProcFS.statm_resident(pid) &.fdiv(1000)
+			end
 
-				_vm_rss = IO.read(file).split[1]
-				_vm_rss ? _vm_rss.to_i.*(pagesize).fdiv(1000) : nil
+			##
+			# = shared_memory(pid = $$)
+			#
+			# Where pid is the process ID.
+			#
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the shared memory for the process.
+			#
+			# The value is in kilobytes.
+			#
+			# The output is an Integer. For example:
+			#    LinuxStat::ProcessInfo.shared_memory
+			#
+			#    => 13996.032
+			#
+			# If the info isn't available it will return nil.
+			def shared_memory(pid = $$)
+				LinuxStat::ProcFS.statm_shared(pid) &.fdiv(1000)
 			end
 
 			##
@@ -282,37 +278,31 @@ module LinuxStat
 			#
 			# The :last_executed_cpu also returns an Integer indicating the last executed cpu of the process.
 			def cpu_stat(pid: $$, sleep: ticks_to_ms_t5)
-				file = "/proc/#{pid}/stat"
 				ticks = get_ticks
+				stat = LinuxStat::ProcFS.ps_stat(pid)
+				uptime = LS::ProcFS.uptime_f
+				return {} unless uptime && !stat.empty?
 
-				return {} unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return {} unless stat
-
-				utime, stime, starttime = *stat.values_at(11, 12, 19).map(&:to_f)
-
-				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+				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)
 
-				return {} unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return {} unless stat
-
-				utime2, stime2, starttime2 = *stat.values_at(11, 12, 19).map(&:to_f)
+				stat = LinuxStat::ProcFS.ps_stat(pid)
+				uptime = LS::ProcFS.uptime_f
+				return {} unless uptime && !stat.empty?
 
-				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+				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),
@@ -348,37 +338,10 @@ module LinuxStat
 			#
 			# This method is more efficient than running LinuxStat::ProcessInfo.cpu_stat()
 			def cpu_usage(pid: $$, sleep: ticks_to_ms_t5)
-				file = "/proc/#{pid}/stat"
-				ticks = get_ticks
-
-				return nil unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				utime, stime, starttime = *stat.values_at(11, 12, 19).map(&:to_f)
-
-				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
-
-				total_time = utime + stime
-				idle1 = uptime - starttime - total_time
-
-				sleep(sleep)
-
-				return nil unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				utime2, stime2, starttime2 = *stat.values_at(11, 12, 19).map(&:to_f)
-				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+				u = cpu_usage_thread(pid, sleep)
+				return nil unless u
 
-				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)
+				u /= LinuxStat::CPU.count
 				u > 100 ? 100.0 : u.round(2)
 			end
 
@@ -405,40 +368,10 @@ module LinuxStat
 			#
 			# But if the info isn't available, it will return nil.
 			def thread_usage(pid: $$, sleep: ticks_to_ms_t5)
-				file = "/proc/#{pid}/stat"
-				ticks = get_ticks
-
-				return nil unless File.readable?(file)
+				u = cpu_usage_thread(pid, sleep)
+				return nil unless u
 
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				utime, stime, starttime = *stat.values_at(11, 12, 19).map(&:to_f)
-
-				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
-
-				total_time = utime + stime
-				idle1 = uptime - starttime - total_time
-
-				sleep(sleep)
-
-				return nil unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				utime2, stime2, starttime2 = *stat.values_at(11, 12, 19).map(&:to_f)
-
-				uptime = IO.read('/proc/uptime'.freeze).to_f * 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
 
@@ -460,11 +393,7 @@ module LinuxStat
 			#
 			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
 			def threads(pid = $$)
-				file = "/proc/#{pid}/stat".freeze
-				return nil unless File.readable?(file)
-
-				data = IO.read(file).split(/(\(.*\))/)[-1] &.split &.at(17)
-				data ? data.to_i : nil
+				LinuxStat::ProcFS.ps_stat(pid)[16]
 			end
 
 			##
@@ -485,11 +414,7 @@ module LinuxStat
 			#
 			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
 			def last_executed_cpu(pid = $$)
-				file = "/proc/#{pid}/stat".freeze
-				return nil unless File.readable?(file)
-
-				data = IO.read(file).split(/(\(.*\))/)[-1] &.split &.at(36)
-				data ? data.to_i : nil
+				LinuxStat::ProcFS.ps_stat(pid)[35]
 			end
 
 			##
@@ -566,21 +491,15 @@ module LinuxStat
 			#
 			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
 			def start_time_epoch(pid = $$)
-				stat_file = "/proc/#{pid}/stat".freeze
-				uptime = "/proc/uptime".freeze
-
-				@@u_readable ||= File.readable?(uptime)
-				return nil unless @@u_readable && File.readable?(stat_file)
+				uptime = LS::ProcFS.uptime_f
+				stat = LinuxStat::ProcFS.ps_stat(pid)[18]
 
-				stat = IO.read(stat_file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				u = IO.foreach(uptime, ' '.freeze).next.to_f
-				st = stat[19].to_f / get_ticks
+				return nil unless uptime && stat
+				st = stat.to_f / get_ticks
 
 				# Getting two Time objects and dealing with floating point numbers
-				# Just to make sure the time goes monotonically
-				Time.now.-(u - st).to_i
+				# Just to make sure the time goes monotonically unless the clock changes
+				Time.now.-(uptime - st).to_i
 			end
 
 			##
@@ -619,17 +538,10 @@ module LinuxStat
 			#
 			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
 			def running_time(pid = $$)
-				stat_file = "/proc/#{pid}/stat".freeze
-				uptime = "/proc/uptime".freeze
-
-				@@u_readable ||= File.readable?(uptime)
-				return nil unless @@u_readable && File.readable?(stat_file)
-
-				stat = IO.read(stat_file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				IO.foreach(uptime, ' '.freeze).next.to_f
-					.-(stat[19].to_f / get_ticks).round(2)
+				uptime = LS::ProcFS.uptime_f
+				stat = LinuxStat::ProcFS.ps_stat(pid)[18]
+				return nil unless uptime && stat
+				uptime.-(stat.to_f / get_ticks).round(2)
 			end
 
 			##
@@ -651,13 +563,7 @@ module LinuxStat
 			# If the info isn't available or the argument passed doesn't exist as a process ID,
 			# it will return an empty String.
 			def state(pid = $$)
-				file = "/proc/#{pid}/stat".freeze
-				return ''.freeze unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1]
-				return '' unless stat
-
-				stat[/\s.+?/].strip
+				LinuxStat::ProcFS.ps_state(pid)
 			end
 
 			##
@@ -670,13 +576,7 @@ module LinuxStat
 			#
 			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
 			def nice(pid = $$)
-				file = "/proc/#{pid}/stat"
-				return nil unless File.readable?(file)
-
-				stat = IO.read(file).split(/(\(.*\))/)[-1] &.split
-				return nil unless stat
-
-				stat[16].to_i
+				LinuxStat::ProcFS.ps_stat(pid)[15]
 			end
 
 			##
@@ -709,6 +609,41 @@ 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 an Integer.
+			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
+			end
+
+			##
+			# = def cpu_times(pid = $$)
+			#
+			# Shows the CPU time used by the process.
+			#
+			# The return value is a Hash.
+			def cpu_times(pid = $$)
+				v = cpu_time(pid)
+				return {} unless v
+
+				hour = v / 3600
+				min = v % 3600 / 60
+				sec = v % 60
+
+				{
+					hour: hour,
+					minute: min,
+					second: sec
+				}
+			end
+
 			alias count_cpu nproc
 
 			private
@@ -728,8 +663,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