linux_stat 0.7.4 → 0.9.2

data/lib/linux_stat/prettify_bytes.rb

@@ -100,10 +100,7 @@ module LinuxStat
 
 			private
 			def pad_left(n, mantissa_length = 2)
-				n = n.round(mantissa_length)
-				exp, mant = n.to_s.split(?..freeze)
-				m = mant.length < mantissa_length ? mant + ?0.freeze * (mantissa_length - mant.length) : mant
-				exp + ?..freeze + m
+				sprintf("%.#{mantissa_length}f".freeze, n)
 			end
 		end
 	end

data/lib/linux_stat/process.rb

@@ -6,7 +6,7 @@ module LinuxStat
 			#
 			# The return type is an Array of Integers.
 			def list
-				Dir['/proc/*'].select! { |x|
+				Dir['/proc/*'].select { |x|
 					pid = File.split(x)[1]
 					pid.to_i.to_s == pid
 				}.map! { |x| File.split(x)[-1].to_i }

data/lib/linux_stat/process_info.rb

@@ -203,13 +203,13 @@ module LinuxStat
 			end
 
 			##
-			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# Where pid is the process ID and sleep time is the interval between measurements.
 			#
 			# By default it is the id of the current process ($$), and sleep is LinuxStat::Sysconf.sc_clk_tck
 			#
-			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck.
+			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5.
 			#
 			# * Note 1:
 			# 1. Do note that the sleep time can slow down your application.
@@ -244,20 +244,22 @@ module LinuxStat
 			# Only use this method if you need all of the data at once, in such case, it's more efficient to use this method.
 			#
 			# The :last_executed_cpu also returns an Integer indicating the last executed cpu of the process.
-			def cpu_stat(pid: $$, sleep: ticks_to_ms)
+			def cpu_stat(pid: $$, sleep: ticks_to_ms_t5)
 				file = "/proc/#{pid}/stat"
-				return {} unless File.readable?(file)
-
 				ticks = get_ticks
 
+				return {} unless File.readable?(file)
 				utime, stime, starttime = IO.read(file)
 					.split.values_at(13, 14, 21).map(&:to_f)
+
 				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
 
 				total_time = utime + stime
 				idle1 = uptime - starttime - total_time
 
 				sleep(sleep)
+
+				return {} unless File.readable?(file)
 				stat = IO.read(file).split
 
 				utime2, stime2, starttime2 = stat.values_at(13, 14, 21).map(&:to_f)
@@ -267,25 +269,25 @@ module LinuxStat
 				idle2 = uptime - starttime2 - total_time2
 
 				totald = idle2.+(total_time2).-(idle1 + total_time)
-				cpu = totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+				cpu_u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
 
 				{
-					cpu_usage: cpu,
+					cpu_usage: cpu_u > 100 ? 100.0 : cpu_u.round(2),
 					threads: stat[19].to_i,
 					last_executed_cpu: stat[38].to_i
 				}
 			end
 
 			##
-			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# Where pid is the process ID and sleep time is the interval between measurements.
 			#
-			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
 			#
 			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
 			#
-			# It retuns the CPU usage in Float.
+			# It retuns the CPU usage as Float.
 			#
 			# For example:
 			#
@@ -293,19 +295,75 @@ module LinuxStat
 			#
 			#    => 10.0
 			#
+			# 10.0 means it's using 10% of the total processing power of the system.
+			#
+			# The value is divided with the configured number of CPU and not online CPU.
+			#
 			# A value of 100.0 indicates it is using 100% processing power available to the system.
 			#
 			# But if the info isn't available, it will return nil.
 			#
 			# This method is more efficient than running LinuxStat::ProcessInfo.cpu_stat()
-			def cpu_usage(pid: $$, sleep: ticks_to_ms)
+			def cpu_usage(pid: $$, sleep: ticks_to_ms_t5)
 				file = "/proc/#{pid}/stat"
+				ticks = get_ticks
+
 				return nil unless File.readable?(file)
+				utime, stime, starttime = IO.read(file)
+					.split.values_at(13, 14, 21).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)
+				utime2, stime2, starttime2 = IO.read(file)
+					.split.values_at(13, 14, 21).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)
+				u > 100 ? 100.0 : u.round(2)
+			end
+
+			##
+			# = thread_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
+			#
+			# Where pid is the process ID and sleep time is the interval between measurements.
+			#
+			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
+			#
+			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
+			#
+			# It retuns the per core CPU usage as Float.
+			#
+			# For example:
+			#
+			#    LinuxStat::ProcessInfo.core_usage
+			#
+			#    => 200.0
+			#
+			# A value of 100.0 indicates it is using 100% processing power of a core.
+			#
+			# The value could be 0 to (100 * the number of CPU threads (including hyperthreading) in the system)
+			#
+			# 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)
 				utime, stime, starttime = IO.read(file)
 					.split.values_at(13, 14, 21).map(&:to_f)
+
 				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
 
 				total_time = utime + stime
@@ -313,15 +371,21 @@ module LinuxStat
 
 				sleep(sleep)
 
+				return nil unless File.readable?(file)
 				utime2, stime2, starttime2 = IO.read(file)
 					.split.values_at(13, 14, 21).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)
-				totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+
+				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)
+
+				cpu_count_t100 = cpu_count * 100
+				u > cpu_count_t100 ? cpu_count_t100 : u.round(2)
 			end
 
 			##
@@ -491,7 +555,9 @@ module LinuxStat
 			# For example:
 			#    LinuxStat::ProcessInfo.running_time 14183
 			#
-			#    => 1947.619999999999
+			#    => 1947.61
+			#
+			# It always rounds the float number upto 2 decimal places
 			#
 			# 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 = $$)
@@ -501,7 +567,8 @@ module LinuxStat
 				@@u_readable ||= File.readable?(uptime)
 				return nil unless @@u_readable && File.readable?(stat_file)
 
-				IO.foreach(uptime, ' '.freeze).next.to_f - (IO.read(stat_file).split[21].to_i / get_ticks)
+				IO.foreach(uptime, ' '.freeze).next.to_f
+					.-(IO.read(stat_file).split[21].to_f / get_ticks).round(2)
 			end
 
 			##
@@ -544,18 +611,57 @@ module LinuxStat
 				IO.foreach(file, ' ').first(19)[-1].to_i
 			end
 
+			##
+			# = nproc(pid = $$)
+			# Returns the cpu allocated to the process.
+			#
+			# The output value is an Integer.
+			#
+			# For example:
+			#    $ taskset -c 0 irb
+			#
+			#    irb(main):001:0> require 'linux_stat'
+			#
+			#    => true
+			#
+			#    irb(main):002:0> LinuxStat::ProcessInfo.nproc
+			#
+			#    => 1
+			#
+			#    irb(main):003:0> LinuxStat::ProcessInfo.nproc 11562
+			#
+			#    => 3
+			#
+			#    irb(main):004:0> LinuxStat::ProcessInfo.nproc 12513
+			#
+			#    => 4
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
+			def nproc(pid = $$)
+				LinuxStat::Nproc.count_cpu_for_pid(pid)
+			end
+
+			alias count_cpu nproc
+
 			private
 			def get_ticks
-				@@ticks ||= Sysconf.sc_clk_tck
+				@@sc_clk_tck ||= LinuxStat::Sysconf.sc_clk_tck
+				@@ticks ||= @@sc_clk_tck < 1 ? 100 : @@sc_clk_tck
 			end
 
 			# Just to avoid multiple calculations!...
-			def ticks_to_ms
-				@@ms ||= 1.0 / get_ticks
+			# ticks to ms * 5
+			# If ticks is 100, it will return 0.05
+			def ticks_to_ms_t5
+				@@ms_t5 ||= 1.0 / get_ticks * 5
 			end
 
 			def pagesize
-				@@pagesize ||= LinuxStat::Sysconf.pagesize
+				@@pagesize ||= LinuxStat::Sysconf.pagesize.to_i
+			end
+
+			def cpu_count
+				@@nprocessors_conf ||= LinuxStat::CPU.count
 			end
 		end
 	end

data/lib/linux_stat/swap.rb

@@ -117,7 +117,7 @@ module LinuxStat
 				val = IO.readlines('/proc/swaps').drop(1)
 				return [[], []] if val.empty?
 
-				val.map { |x|
+				val.map! { |x|
 					x.strip.split.values_at(2, 3).map!(&:to_i)
 				}.transpose
 			end

data/lib/linux_stat/version.rb

@@ -1,3 +1,3 @@
 module LinuxStat
-	VERSION ||= "0.7.4"
+	VERSION ||= "0.9.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linux_stat
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.9.2
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-17 00:00:00.000000000 Z
+date: 2020-12-22 00:00:00.000000000 Z
 dependencies: []
 description: Linux only, efficient linux system utilization reporting and system monitoring
   gem
@@ -20,6 +20,7 @@ extensions:
 - ext/fs_stat/extconf.rb
 - ext/sysconf/extconf.rb
 - ext/utsname/extconf.rb
+- ext/nproc/extconf.rb
 extra_rdoc_files:
 - README.md
 files:
@@ -30,6 +31,8 @@ files:
 - exe/linuxstat.rb
 - ext/fs_stat/extconf.rb
 - ext/fs_stat/fs_stat.c
+- ext/nproc/extconf.rb
+- ext/nproc/nproc.c
 - ext/sysconf/extconf.rb
 - ext/sysconf/sysconf.c
 - ext/utsname/extconf.rb