linux_stat 2.3.0 → 2.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2caab049f35d0dcad515eff80928136273b729219cc70a7c07f6823282f0a39c
-  data.tar.gz: eb8a5a546f795116e825bd704da6380a81b197b61ffd4125d0dc2c267e6ea808
+  metadata.gz: c9155ed8b1f6161a8bafcb9fbd9f1a1d9f70b018ca62aabf49ad1c7439030ee2
+  data.tar.gz: 22e52732cd8c8a2fca1f34ca9ece06178373c800ddbc200c42d1a61d49c29995
 SHA512:
-  metadata.gz: cd77811626f97fe248885dc2686447e584801d607fb2147200852ff3debc36e0fe37fe8a139a71fe67398ac3fde074c821b68428ccbb6a9cf4126385bcfa23df
-  data.tar.gz: 89a2646c48f68d48e02bc5593bb4f616090c5e1c30045a05eb39a3d0b1c41412853ee09c600b11d4f1e59544bf49e5409fb1d2906d666290989683a707142358
+  metadata.gz: d1f781908039e1946676f8a1502321b530538aef6d303976b07930c6d8933e7a45ca671e1aa3438fc774caa68c1b939f1ee12f47a5a6399523700b46cfb0c9f5
+  data.tar.gz: cd51272b3c145c9a57a5b3ae444c21119430106436e29c843420269cbad47044fdc4e3836bf86e61404c6df20f462164dc673ec5e6d76b4acacfcc37effc61c8

data/README.md

@@ -38,18 +38,36 @@ It only works on Linux, and detecting the OS is upto the user of this gem.
 2. Ruby: Ruby 2.3.0 and above.
 
 ## Build Dependencies:
-+ You need to have the C compiler installed to be able to compile the C extensions.
-On Arch Linux:
+#### You need to have the C compiler installed to be able to compile the C extensions.
+
++ On Arch Linux / Manjaro / Archlabs / Other Arch Based Distributions
+```
+# pacman -S gcc make ruby
+```
+
++ On Debian / Ubuntu / Linux Mint / Pop!_OS / Raspberry Pi OS / Other Debian Based Distributions
+```
+# apt install gcc build-essential ruby ruby-dev build-essential
+```
+
++ Gentoo / Gentoo Based Distributions
+```
+# emerge --ask dev-lang/ruby
+```
+
++ Fedora / AmazonLinux* / CentOS* / Other RedHat Based Distributions
 ```
-# pacman -S gcc make
+# yum install gcc ruby-devel ruby make
 ```
 
-On Debian based systems:
+You can run linux_stat on *AmazonLinux and *CentOS if you have Ruby 2.3.0+.
+
++ OpenSUSE
 ```
-# apt install gcc build-essential ruby-dev
+# zypper install gcc ruby ruby-devel make
 ```
 
-+ You can remove the packages once the program is installed.
++ You can remove the above packages once the gem is installed.
 
 ---
 
@@ -62,13 +80,28 @@ You can install hwdata simply.
 + Arch:
 
 ```
-sudo pacman -S hwids
+# pacman -S hwids
 ```
 
 + Debian based systems:
 
 ```
-sudo apt install hwdata
+# apt install hwdata
+```
+
++ Gentoo / Gentoo Based Distributions
+```
+# emerge --ask sys-apps/hwids
+```
+
++ Fedora / Amazon Linux / CentOS
+```
+# yum install hwdata
+```
+
++ OpenSUSE
+```
+zypper install hwdata
 ```
 
 But without hwdata, it won't show such information.

data/exe/linuxstat.rb

@@ -11,7 +11,7 @@ end
 T_FMT = '%d'.freeze
 
 # Check the number of iterations
-iterations = (ARGV.find { |x| x.to_i.to_s == x } || 1).to_i
+iterations = (ARGV.find { |x| LinuxStat::Misc.integer?(x) } || 1).to_i
 
 Integer.class_exec do
 	define_method(:clamp) { |min, max|
@@ -73,14 +73,14 @@ conflicting.each do |x, y, z|
 		rev = ARGV.reverse
 
 		if rev.index { |_x| _x[y] } < rev.index { |_x| _x[z] }
-			hash.merge!(o1 => true)
+			hash.store(o1, true)
 		else
-			hash.merge!(o2 => true)
+			hash.store(o2, true)
 		end
 	elsif m1
-		hash.merge!(o1 => true)
+		hash.store(o1, true)
 	elsif m2
-		hash.merge!(o2 => true)
+		hash.store(o2, true)
 	end
 end
 
@@ -266,6 +266,6 @@ if PRINT_TIME
 	).*(1_000_000)
 
 	puts "\e[38;2;255;255;0m:: Warning total time also depends on your terminal speed!\e[0m"
-	puts "Total Real Time: #{T_FMT % total_real_t}ms"
-	puts "Total CPU Time: #{T_FMT % total_cpu_t}ms"
+	puts "Total Real Time: #{T_FMT % total_real_t}\u03BCs"
+	puts "Total CPU Time: #{T_FMT % total_cpu_t}\u03BCs"
 end

data/ext/misc/integer/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'linux_stat/misc/integer'

data/ext/misc/integer/integer?.c

@@ -0,0 +1,63 @@
+/*
+	Validates if a String is integer or not.
+
+	Conditions:
+		- The String can start with - (negative)
+		- If the Argument is a BigInt or Integer, or anything else, return false
+		- The String cannot have anything other than 0 to 9
+		- The String can have leading zeroes and negative sign:
+			Example 1: "-00999" which translates to Ruby's -999 (decimal)
+			Example 2: "000999" translates to 999
+		- If it fails to determine, it returns nil instead of false
+		- It doesn't raise any error. Handing nil is enough to indicate that it failed.
+*/
+
+#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
+
+#include <limits.h>
+#include "ruby.h"
+
+VALUE isNumber(volatile VALUE obj, volatile VALUE val) {
+	// But we don't expect anything other than String though as Argument.
+	// Note that raising ArgumentError or any kind of Error shouldn't be done here
+	// Otherwise Integer(n) is the best method in Ruby.
+	if (!RB_TYPE_P(val, T_STRING))
+		return Qnil ;
+
+	char *str = StringValuePtr(val) ;
+	char ch = str[0] ;
+
+	// If the string is empty, return false
+	if (!ch) return Qfalse ;
+
+	unsigned char i = ch == '-' ? 1 : 0 ;
+	if (!str[i]) return Qfalse ;
+
+	unsigned char max = UCHAR_MAX ;
+
+	# pragma GCC unroll 4
+	while((ch = str[i++])) {
+		if (ch < 48 || ch > 57)
+			return Qfalse ;
+
+		if (i == max)
+			return Qnil ;
+	}
+
+	return Qtrue ;
+}
+
+void Init_integer() {
+	VALUE linuxStat = rb_define_module("LinuxStat") ;
+	VALUE misc = rb_define_module_under(linuxStat, "Misc") ;
+
+	rb_define_module_function(misc, "integer?", isNumber, 1) ;
+}

data/ext/procfs/procfs.c

@@ -13,6 +13,7 @@
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
+#include <glob.h>
 #include "ruby.h"
 #include "uptime.h"
 #include "statm.h"
@@ -22,6 +23,8 @@
 int Init_procfs() {
 	VALUE _linux_stat = rb_define_module("LinuxStat") ;
 	VALUE _procfs = rb_define_module_under(_linux_stat, "ProcFS") ;
+	VALUE _cpu = rb_define_module_under(_linux_stat, "CPU") ;
+	VALUE _process = rb_define_module_under(_linux_stat, "Process") ;
 
 	// uptime
 	rb_define_module_function(_procfs, "uptime_f", uptime_f, 0) ;
@@ -40,4 +43,7 @@ int Init_procfs() {
 	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) ;
+	rb_define_module_function(_procfs, "cpu_times", cpuTimes, 0) ;
+	rb_define_module_function(_procfs, "list_process", listProcess, 0) ;
+
 }

data/ext/procfs/stat.h

@@ -17,6 +17,29 @@ static VALUE ps_state(volatile VALUE obj, volatile VALUE pid) {
 	return rb_str_new_cstr(_s) ;
 }
 
+static VALUE listProcess(volatile VALUE obj) {
+	VALUE ary = rb_ary_new() ;
+
+	glob_t globlist ;
+	int status = glob("/proc/[0-9]*/", GLOB_NOSORT, NULL, &globlist) ;
+
+	if (status == GLOB_NOSPACE || status == GLOB_ABORTED || status == GLOB_NOMATCH) {
+		globfree(&globlist) ;
+		return ary ;
+	}
+
+	char *v, *token ;
+	unsigned int i = 0 ;
+	unsigned int num ;
+
+	while(v = globlist.gl_pathv[i++]) {
+		if (sscanf(v, "/proc/%u", &num) == 1) rb_ary_push(ary, UINT2NUM(num)) ;
+	}
+
+	globfree(&globlist) ;
+	return ary ;
+}
+
 static VALUE ps_times(volatile VALUE obj, volatile VALUE pid) {
 	int _pid = FIX2INT(pid) ;
 	if (_pid < 0) return Qnil ;
@@ -117,3 +140,46 @@ static VALUE ps_stat(volatile VALUE obj, volatile VALUE pid) {
 	INT2NUM(exit_code)
 	) ;
 }
+
+static VALUE cpuTimes(volatile VALUE obj) {
+	VALUE ary = rb_ary_new() ;
+	FILE *f = fopen("/proc/stat", "r") ;
+
+	if (!f) return ary ;
+
+	unsigned long user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice ;
+	char line[1024] ;
+	char cpuCode[7] ;
+	float ticks = sysconf(_SC_CLK_TCK) ;
+	char scanStatus ;
+
+	while(fgets(line, 1023, f)) {
+		if (!(line[0] == 'c' && line[1] == 'p' && line[2] == 'u')) break ;
+
+		scanStatus = sscanf(line,
+			"%7[cpu0-9] %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
+			cpuCode, &user, &nice, &system, &idle, &iowait, &irq, &softirq, &steal, &guest, &guest_nice
+		) ;
+
+		if (scanStatus != 11) break ;
+
+		VALUE innerHash = rb_hash_new() ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("cpu")), rb_str_new_cstr(cpuCode)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("user")), rb_float_new(user / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("nice")), rb_float_new(nice / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("system")), rb_float_new(system / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("idle")), rb_float_new(idle / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("iowait")), rb_float_new(iowait / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("irq")), rb_float_new(irq / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("softirq")), rb_float_new(softirq / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("steal")), rb_float_new(steal / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("guest")), rb_float_new(guest / ticks)) ;
+		rb_hash_aset(innerHash, ID2SYM(rb_intern("guest_nice")), rb_float_new(guest_nice / ticks)) ;
+
+		rb_ary_push(ary, innerHash) ;
+	}
+
+	fclose(f) ;
+
+	return ary ;
+}

data/lib/linux_stat/battery.rb

@@ -308,7 +308,7 @@ module LinuxStat
 					ret[:charge_full_wh] = c_f_wh if c_f_wh
 					ret[:charge_percentage] = charge_percentage if charge_percentage
 
-					h.merge!(File.split(x)[-1].to_sym => ret)
+					h.store(File.split(x)[-1].to_sym, ret)
 				end
 				h
 			end

data/lib/linux_stat/cpu.rb

@@ -21,24 +21,53 @@ module LinuxStat
 			#
 			#    => {0=>84.38, 1=>100.0, 2=>50.0, 3=>87.5, 4=>87.5}
 			#
+			# It discards any offline CPU or disabled CPU.
+			# For example, if your system CPU has 4 cores, and you disabled core 3, the output will be:
+			#    LinuxStat::CPU.stat
+			#
+			#    => {0=>26.67, 1=>0.0, 2=>20.0, 4=>20.0}
+			#
 			# If the information is not available, it will return an empty Hash
 			def stat(sleep = ticks_to_ms_t5)
 				return {} unless stat?
 
-				data = IO.readlines('/proc/stat'.freeze).select { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
+				data = IO.readlines('/proc/stat'.freeze).select { |x| x[/^cpu\d*/] }
+				cpu_names1 = []
+				data.map! { |x|
+					splitted = x.split
+					name = splitted.shift[/\d*$/]
+					cpu_names1.push(name.empty? ? 0 : name.to_i + 1)
+					splitted.map!(&:to_f)
+				}
+
 				sleep(sleep)
-				data2 = IO.readlines('/proc/stat'.freeze).select { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
+				data2 = IO.readlines('/proc/stat'.freeze).select { |x| x[/^cpu\d*/] }
+
+				cpu_names2 = []
+				data2.map! { |x|
+					splitted = x.split
+					name = splitted.shift[/\d*$/]
+					cpu_names2.push(name.empty? ? 0 : name.to_i + 1)
+					splitted.map!(&:to_f)
+				}
 
 				# 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.
-				dl, d2l = data.length, data2.length
-				min = dl > d2l ? d2l : dl
+				dl, d2l = cpu_names1.length, cpu_names2.length
+				if dl > d2l
+					min = d2l
+					cpu_cores = cpu_names2
+				else
+					min = dl
+					cpu_cores = cpu_names1
+				end
 
 				min.times.reduce({}) do |h, x|
-					user, nice, sys, idle, iowait, irq, softirq, steal = *data[x].drop(1)
-					user2, nice2, sys2, idle2, iowait2, irq2, softirq2, steal2 = *data2[x].drop(1)
+					cpu_core = cpu_cores[x]
+					user, nice, sys, idle, iowait, irq, softirq, steal = *data[x]
+					user2, nice2, sys2, idle2, iowait2, irq2, softirq2, steal2 = *data2[x]
 
 					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)
@@ -46,7 +75,8 @@ module LinuxStat
 					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.store(cpu_core, res)
+					h
 				end
 			end
 
@@ -203,12 +233,16 @@ module LinuxStat
 
 				h = {}
 				@@cur_f.each { |id, file|
-					h.merge!(id => IO.read(file).to_i) if File.readable?(file)
+					h.store(id, IO.read(file).to_i) if File.readable?(file)
 				}
 
 				h
 			end
 
+			def times
+				LinuxStat::ProcFS.cpu_times
+			end
+
 			##
 			# Returns a Hash with max core frequencies corresponding to the CPUs.
 			#
@@ -225,7 +259,7 @@ module LinuxStat
 
 				h = {}
 				@@min_f.each { |id, file|
-					h.merge!(id => IO.read(file).to_i) if File.readable?(file)
+					h.store(id, IO.read(file).to_i) if File.readable?(file)
 				}
 
 				h
@@ -247,7 +281,7 @@ module LinuxStat
 
 				h = {}
 				@@min_f.each { |id, file|
-					h.merge!(id => IO.read(file).to_i) if File.readable?(file)
+					h.store(id, IO.read(file).to_i) if File.readable?(file)
 				}
 
 				h
@@ -271,7 +305,7 @@ module LinuxStat
 
 				h = {}
 				@@scaling_g.each { |id, file|
-					h.merge!(id => IO.read(file).tap(&:strip!)) if File.readable?(file)
+					h.store(id, IO.read(file).tap(&:strip!)) if File.readable?(file)
 				}
 
 				h
@@ -293,14 +327,91 @@ module LinuxStat
 
 				h = {}
 				@@scaling_av_g.each { |id, file|
-					h.merge!(id => IO.read(file).split.each(&:strip!)) if File.readable?(file)
+					h.store(id, IO.read(file).split.each(&:strip!)) if File.readable?(file)
 				}
 
 				h
 			end
 
+			##
+			# Returns the number of physical cores on the system.
+			#
+			# The return value is an Array of Integers. Each number denoting the physical processor number.
+			# You can later use this to schedule tasks or something else (not provided by LinuxStat).
+			#
+			# However, if the information isn't available on /sys/devices/system/cpu[0-9]*/topology/thread_siblings_list, it will return an empty Array.
+			def physical_core_list
+				physical_cores = []
+				hyperthreaded = {}
+
+				return [] unless File.readable?('/sys/devices/system/cpu/'.freeze)
+				entries = Dir.entries('/sys/devices/system/cpu/'.freeze)
+				entries.delete(?..freeze)
+				entries.delete('..'.freeze)
+
+				entries.each do |x|
+					if x[0..2] == 'cpu'.freeze && LinuxStat::Misc.integer?(x[3..-1])
+						file = "/sys/devices/system/cpu/#{x}/topology/thread_siblings_list"
+						next unless File.readable?(file)
+
+						data = IO.read(file)
+						data.strip!
+
+						val = data.split(?,.freeze).map(&:to_i)
+						val.shift
+
+						# Add items has for fast lookup.
+						# This hash includes all hyper threaded cores that doesn't map to anything.
+						# But this hash has the purpose to look up for items and not include in the list of physical_cores
+						# This is just an array, but can look for keys in O(1), so it's faster than ary.find() { ... }.
+						val.each { |x| hyperthreaded.store(x, nil) }
+
+						key = x[3..-1].to_i
+						physical_cores << key unless hyperthreaded.key?(key)
+					end
+				end
+
+				physical_cores
+			end
+
+			##
+			# Returns the number of physical cores on the system.
+			#
+			# The return value is an Array of Integers. Each number denoting the hyperthreaded processor number.
+			# You can later use this to schedule tasks or something else (not provided by LinuxStat).
+			#
+			# However, if the information isn't available on /sys/devices/system/cpu[0-9]*/topology/thread_siblings_list, it will return an empty Array.
+			def hyperthreaded_core_list
+				hyperthreaded = {}
+
+				return [] unless File.readable?('/sys/devices/system/cpu/'.freeze)
+				entries = Dir.entries('/sys/devices/system/cpu/'.freeze)
+				entries.delete(?..freeze)
+				entries.delete('..'.freeze)
+
+				entries.each do |x|
+					if x[0..2] == 'cpu'.freeze && LinuxStat::Misc.integer?(x[3..-1])
+						file = "/sys/devices/system/cpu/#{x}/topology/thread_siblings_list"
+						next unless File.readable?(file)
+
+						data = IO.read(file)
+						data.strip!
+
+						val = data.split(?,.freeze).map(&:to_i)
+						val.shift
+
+						# Add items has for fast lookup to get rid of duplicate items.
+						val.each { |x| hyperthreaded.store(x, nil) unless hyperthreaded.key?(x) }
+					end
+				end
+
+				hyperthreaded.keys
+			end
+
 			alias usages stat
 			alias usage total_usage
+			alias physical_cores physical_core_list
+			alias hyperthreaded_cores hyperthreaded_core_list
 
 			private
 			def cpuinfo

data/lib/linux_stat/mounts.rb

@@ -58,7 +58,7 @@ module LinuxStat
 			def tmpfs
 				ret = {}
 				mounts.each { |x|
-					ret.merge!({x.split[1] => x}) if x.start_with?('tmpfs '.freeze)
+					ret.store(x.split[1], x) if x.start_with?('tmpfs '.freeze)
 				}
 				ret
 			end
@@ -115,7 +115,7 @@ module LinuxStat
 
 					unless x.empty?
 						_x = x.split
-						m.merge!(_x[0] => _x[1])
+						m.store(_x[0], _x[1])
 					end
 				end
 				m
@@ -146,7 +146,7 @@ module LinuxStat
 						_x = x.split
 						total, free, available, used = fs_info(_x[1])
 
-						m.merge!(_x[0] => {
+						m.store(_x[0], {
 							mountpoint: _x[1],
 
 							total: total,

data/lib/linux_stat/net.rb

@@ -120,8 +120,8 @@ module LinuxStat
 
 					r.each_with_index { |x, i|
 						downcased = x.downcase
-						h.merge!(:r => i) if downcased.start_with?('receive'.freeze)
-						h.merge!(:t => i) if downcased.start_with?('transmit'.freeze)
+						h.store(:r, i) if downcased.start_with?('receive'.freeze)
+						h.store(:t, i) if downcased.start_with?('transmit'.freeze)
 					}
 
 					data_0 = data.next.gsub(?|.freeze, ' %'.freeze)

data/lib/linux_stat/os.rb

@@ -234,7 +234,8 @@ module LinuxStat
 					value[0] = ''.freeze if value[0] == ?".freeze
 					value[-1] = ''.freeze if value[-1] == ?".freeze
 
-					h.merge!( key.to_sym => value )
+					h.store(key.to_sym, value)
+					h
 				}
 			end
 		end

data/lib/linux_stat/pci.rb

@@ -76,7 +76,7 @@ module LinuxStat
 						kernel_driver: kernel_driver
 					}
 
-					ret.merge!(hwdata: query) unless query.empty?
+					ret.store(:hwdata, query) unless query.empty?
 
 					ret
 				}
@@ -186,14 +186,14 @@ module LinuxStat
 							vendor: vendor, device: device
 						}
 
-						ret.merge!(sub_vendor: sub_vendor) if sub_vendor
-						ret.merge!(sub_device: sub_device) if sub_device
+						ret.store(:sub_vendor, sub_vendor) if sub_vendor
+						ret.store(:sub_device, sub_device) if sub_device
 
-						ret.merge!(kernel_driver: kernel_driver) if kernel_driver
-						ret.merge!(revision: revision) unless revision.empty?
-						ret.merge!(irq: irq) if irq
-						ret.merge!(enable: enable) unless enable.nil?
-						ret.merge!(hwdata: query) unless query.empty?
+						ret.store(:kernel_driver, kernel_driver) if kernel_driver
+						ret.store(:revision, revision) unless revision.empty?
+						ret.store(:irq, irq) if irq
+						ret.store(:enable, enable) unless enable.nil?
+						ret.store(:hwdata, query) unless query.empty?
 
 						ret
 					rescue StandardError
@@ -355,7 +355,7 @@ module LinuxStat
 
 					if sub_vendor_id && sub_device_id
 						sub_product = vendor.dig(1, product_id, 1, sub_vendor_id, sub_device_id)
-						ret.merge!(sub_system: sub_product) if sub_product
+						ret.store(:sub_system, sub_product) if sub_product
 					end
 
 					ret

data/lib/linux_stat/process.rb

@@ -1,25 +1,15 @@
 module LinuxStat
 	# Shows various information about a process that is either
 	# running, sleeping, idle or a zombie.
-
 	module Process
 		class << self
 			##
 			# Returns the list of processes from /proc/.
+			# The output doesn't guarantee a sorted list, in fact it's shuffled most of the time.
 			#
 			# The return type is an Array of Integers.
 			def list
-				d = Dir['/proc/*'.freeze]
-				ret, i = [], -1
-				count = d.length
-
-				while(i += 1) < count
-					pid = File.split(d[i])[1]
-					pid_i = pid.to_i
-					ret << pid_i if pid_i.to_s == pid
-				end
-
-				ret
+				LinuxStat::ProcFS.list_process
 			end
 
 			##
@@ -27,7 +17,7 @@ module LinuxStat
 			#
 			# The return type is Integer.
 			def count
-				list.length
+				LinuxStat::ProcFS.list_process.length
 			end
 
 			##
@@ -36,14 +26,14 @@ module LinuxStat
 			def names
 				h, i = {}, -1
 
-				l = list
+				l = LinuxStat::ProcFS.list_process
 				count = l.length
 
 				while(i += 1) < count
 					x = l[i]
 
 					begin
-						h.merge!( x => IO.read("/proc/#{x}/comm").strip)
+						h.store(x, IO.read("/proc/#{x}/comm").strip)
 					rescue StandardError
 					end
 				end
@@ -57,7 +47,7 @@ module LinuxStat
 			def cmdlines
 				h, i = {}, -1
 
-				l = list
+				l = LinuxStat::ProcFS.list_process
 				count = l.length
 
 				while(i += 1) < count
@@ -66,7 +56,7 @@ module LinuxStat
 					begin
 						cmdlines = IO.read("/proc/#{x}/cmdline").strip
 						cmdlines.gsub!(?\u0000.freeze, ?\s.freeze)
-						h.merge!( x => cmdlines)
+						h.store(x, cmdlines)
 					rescue StandardError
 					end
 				end
@@ -78,14 +68,14 @@ module LinuxStat
 			def types
 				h, i = {}, -1
 
-				l = list
+				l = LinuxStat::ProcFS.list_process
 				count = l.length
 
 				while(i += 1) < count
 					x = l[i]
 
 					begin
-						h.merge!(x =>
+						h.store(x,
 							case LinuxStat::ProcFS.ps_state(x)
 								when ?S.freeze then :sleeping
 								when ?I.freeze then :idle
@@ -109,7 +99,7 @@ module LinuxStat
 			# Returns all the id of processes that are sleeping.
 			# The return type is an Array of Integers.
 			def sleeping
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?S.freeze
 				}
 			end
@@ -118,7 +108,7 @@ module LinuxStat
 			# Returns all the id of processes that are idle.
 			# The return type is an Array of Integers.
 			def idle
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?I.freeze
 				}
 			end
@@ -127,7 +117,7 @@ module LinuxStat
 			# Returns all the id of processes that are zombies.
 			# The return type is an Array of Integers.
 			def zombie
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?Z.freeze
 				}
 			end
@@ -136,7 +126,7 @@ module LinuxStat
 			# Returns all the id of processes that are running.
 			# The return type is an Array of Integers.
 			def running
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					LinuxStat::ProcFS.ps_state(x) == ?R.freeze
 				}
 			end
@@ -145,7 +135,7 @@ module LinuxStat
 			# Returns all the id of processes that are stopped.
 			# The return type is an Array of Integers.
 			def stopped
-				list.select { |x|
+				LinuxStat::ProcFS.list_process.select { |x|
 					v = LinuxStat::ProcFS.ps_state(x)
 					v == ?T.freeze || v == ?t.freeze
 				}

data/lib/linux_stat/process_info.rb

@@ -36,7 +36,7 @@ module LinuxStat
 
 					if x[/^(read|write)_bytes:\s*\d*$/]
 						splitted = x.split
-						out.merge!(splitted[0].split(?:)[0].to_sym => splitted[-1].to_i)
+						out.store(splitted[0].split(?:)[0].to_sym, splitted[-1].to_i)
 					end
 				}
 

data/lib/linux_stat/swap.rb

@@ -13,7 +13,8 @@ module LinuxStat
 				file = IO.readlines('/proc/swaps'.freeze).drop(1)
 				file.reduce({}) do |h, x|
 					name, *stats = x.strip.split
-					h.merge!(name => stats.map! { |v| v.to_i.to_s == v ? v.to_i : v.to_sym })
+					h.store(name, stats.map! { |v| LinuxStat::Misc.integer?(v) ? v.to_i : v.to_sym })
+					h
 				end
 			end
 

data/lib/linux_stat/thermal.rb

@@ -107,10 +107,10 @@ module LinuxStat
 
 					h = {path: path, name: name}
 
-					h.merge!(label: label) if label
-					h.merge!(key => value)
-					h.merge!(temp_crit: temp_crit) if temp_crit
-					h.merge!(temp_crit: temp_max) if temp_max
+					h.store(:label, label) if label
+					h.store(key, value)
+					h.store(:temp_crit, temp_crit) if temp_crit
+					h.store(:temp_crit, temp_max) if temp_max
 
 					ret.push(h)
 				end

data/lib/linux_stat/usb.rb

@@ -102,20 +102,20 @@ module LinuxStat
 							vendor_id: id_vendor, product_id: id_product
 						}
 
-						ret.merge!(bus_num: bus_num.to_i) unless bus_num.empty?
-						ret.merge!(dev_num: dev_num.to_i) unless dev_num.empty?
+						ret.store(:bus_num, bus_num.to_i) unless bus_num.empty?
+						ret.store(:dev_num, dev_num.to_i) unless dev_num.empty?
 
-						ret.merge!(serial: serial) unless serial.empty?
+						ret.store(:serial, serial) unless serial.empty?
 
-						ret.merge!(hwdata: query) unless query.empty?
-						ret.merge!(product: product) unless product.empty?
-						ret.merge!(manufacturer: manufacturer) unless manufacturer.empty?
+						ret.store(:hwdata, query) unless query.empty?
+						ret.store(:product, product) unless product.empty?
+						ret.store(:manufacturer, manufacturer) unless manufacturer.empty?
 
-						ret.merge!(removable: is_removable) unless is_removable.nil?
-						ret.merge!(authorized: authorized == 1)
+						ret.store(:removable, is_removable) unless is_removable.nil?
+						ret.store(:authorized, authorized == 1)
 
-						ret.merge!(b_max_power: b_max_power) unless b_max_power.empty?
-						ret.merge!(b_max_packet_size0: b_max_packet_size0) if b_max_packet_size0
+						ret.store(:b_max_power, b_max_power) unless b_max_power.empty?
+						ret.store(:b_max_packet_size0, b_max_packet_size0) if b_max_packet_size0
 
 						ret
 					rescue StandardError

data/lib/linux_stat/user.rb

@@ -25,9 +25,11 @@ module LinuxStat
 			def ids
 				return {} unless passwd_readable?
 				passwd_splitted.reduce({}) { |h, x|
-					h.merge!(x[0].to_sym => {
+					h.store(x[0].to_sym, {
 						uid: x[2].to_i, gid: x[3].to_i
 					})
+
+					h
 				}
 			end
 
@@ -42,8 +44,10 @@ module LinuxStat
 			def uids
 				return {} unless passwd_readable?
 				passwd_splitted.reduce({}) { |h, x|
-					h.merge!(x[0].to_sym => x[2].to_i)
+					h.store(x[0].to_sym, x[2].to_i)
+					h
 				}
+
 			end
 
 			##
@@ -59,7 +63,8 @@ module LinuxStat
 				return {} unless passwd_readable?
 
 				passwd_splitted.reduce({}) { |h, x|
-					h.merge!(x[0].to_sym => x[3].to_i)
+					h.store(x[0].to_sym, x[3].to_i)
+					h
 				}
 			end
 
@@ -76,7 +81,8 @@ module LinuxStat
 				return {} unless passwd_readable?
 				passwd.reduce({}) { |h, x|
 					splitted = x.split(?:)
-					h.merge!(splitted[0].to_sym => splitted[5])
+					h.store(splitted[0].to_sym, splitted[5])
+					h
 				}
 			end
 

data/lib/linux_stat/version.rb

@@ -1,3 +1,3 @@
 module LinuxStat
-	VERSION = "2.3.0"
+	VERSION = "2.5.2"
 end

data/lib/linux_stat.rb

@@ -15,6 +15,7 @@
 
 # Miscellaneous Modules
 # Independed and LinuxStat's miscellaneous modules
+require 'linux_stat/misc/integer'
 require 'linux_stat/prettify_bytes'
 require "linux_stat/version"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linux_stat
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.5.2
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-07 00:00:00.000000000 Z
+date: 2021-10-23 00:00:00.000000000 Z
 dependencies: []
 description: Linux only, efficient linux system utilization reporting and system monitoring
   gem
@@ -18,6 +18,7 @@ executables:
 - linuxstat.rb
 extensions:
 - ext/fs_stat/extconf.rb
+- ext/misc/integer/extconf.rb
 - ext/nproc/extconf.rb
 - ext/procfs/extconf.rb
 - ext/sysconf/extconf.rb
@@ -35,6 +36,8 @@ files:
 - ext/fs_stat/extconf.rb
 - ext/fs_stat/fs_stat.c
 - ext/fs_stat/sector_size.h
+- ext/misc/integer/extconf.rb
+- ext/misc/integer/integer?.c
 - ext/nproc/extconf.rb
 - ext/nproc/nproc.c
 - ext/procfs/extconf.rb
@@ -87,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.18
+rubygems_version: 3.2.29
 signing_key:
 specification_version: 4
 summary: Efficient linux system reporting gem