linux_stat 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a392f3c04781b05bb96636a882b6e69143bef15befb094f980c7b542923e0649
-  data.tar.gz: 4ef67fa10ab4210090790b368852cac7deee99965560b201f136f0cd093e9a87
+  metadata.gz: e4f9b433758109c632c7b6358b1fd6c5cda1711e1ab6b8f4a3dae0ce6cc02f6d
+  data.tar.gz: c0273b6cf31ae022adfeb4b9e041426de2841899d08be49f3559ab98175be54d
 SHA512:
-  metadata.gz: 816e423f9a22797022d87a347dbcde20277d0b1d6fa8cc90001367cbdf2012e625400c2a659bbbd308fcf58363c19f2af88ec39d5bcc1fa04ccd4f61d77371b7
-  data.tar.gz: dfae97ea5bd4ef7c0daa4c784d7d951b915121753d8b61363624aaaa12e9559968e623638004accb8438a77b820913e726856e166bd437f1073047b936a83ba1
+  metadata.gz: 3e7b971800222420d9156a791de5857331c923149416a7d4b5d025d57bbb7e9d3ccea8ec47d2236f308a8675bfbcf5d0a2ee0380dab92afed29dc0ace8dcb577
+  data.tar.gz: 7583db616fff644f2798fe779b23ed28cc762eac3d6d8aad0e4c907b21813bcaacc058570516378e7cdf495a51b4906bb5a30221ebb60536af72d91b2795a147

data/README.md

@@ -99,7 +99,7 @@ LinuxStat::CPU.count
 => 4
 
 LinuxStat::CPU.cur_freq
-=> [1998722, 1998401, 1974377, 1875264]
+=> [1999998, 2000003, 2000015, 2000009]
 
 LinuxStat::CPU.max_freq
 => [2000000, 2000000, 2000000, 2000000]
@@ -108,38 +108,38 @@ LinuxStat::CPU.model
 => "Intel(R) Core(TM) i3-6006U CPU @ 2.00GHz"
 
 LinuxStat::CPU.stat
-=> {0=>6.45, 1=>0.0, 2=>0.0, 3=>12.5, 4=>0.0}
+=> {0=>14.29, 1=>25.0, 2=>0.0, 3=>25.0, 4=>14.29}
 
 LinuxStat::CPU.total_usage
-=> 3.45
+=> 18.75
 
 LinuxStat::CPU.usage
-=> 6.45
+=> 14.29
 
 LinuxStat::CPU.usages
-=> {0=>9.68, 1=>11.11, 2=>12.5, 3=>14.29, 4=>12.5}
+=> {0=>16.67, 1=>14.29, 2=>28.57, 3=>0.0, 4=>25.0}
 
 ```
 
 ### LinuxStat::Filesystem
 ```
 LinuxStat::Filesystem.available
-=> 43155402752
+=> 42144575488
 
 LinuxStat::Filesystem.free
-=> 43155402752
+=> 42144575488
 
 LinuxStat::Filesystem.stat
-=> {:total=>119981191168, :free=>43155402752, :used=>76825788416}
+=> {:total=>119981191168, :free=>42144575488, :used=>77836615680}
 
 LinuxStat::Filesystem.stat_raw
-=> {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10535987, :block_avail_unpriv=>10535987, :inodes=>58612160, :free_inodes=>56718515, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
+=> {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10289203, :block_avail_unpriv=>10289203, :inodes=>58612160, :free_inodes=>56716465, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
 
 LinuxStat::Filesystem.total
 => 119981191168
 
 LinuxStat::Filesystem.used
-=> 76825788416
+=> 77836615680
 
 ```
 
@@ -154,15 +154,24 @@ LinuxStat::Kernel.build_date_string
 LinuxStat::Kernel.build_user
 => "souravgoswami@archlinux"
 
+LinuxStat::Kernel.clk_tck
+=> 100
+
 LinuxStat::Kernel.compiler
 => [:gcc, "10.2.0"]
 
 LinuxStat::Kernel.compiler_version
 => "10.2.0"
 
+LinuxStat::Kernel.release
+=> "5.9.1-xanmod1-1"
+
 LinuxStat::Kernel.string
 => "Linux version 5.9.1-xanmod1-1 (souravgoswami@archlinux) (gcc (GCC) 10.2.0, GNU ld (GNU Binutils) 2.35.1) #1 SMP PREEMPT Wed, 21 Oct 2020 01:11:20 +0000"
 
+LinuxStat::Kernel.ticks
+=> 100
+
 LinuxStat::Kernel.version
 => "5.9.1-xanmod1-1"
 
@@ -171,29 +180,29 @@ LinuxStat::Kernel.version
 ### LinuxStat::Memory
 ```
 LinuxStat::Memory.available
-=> 403724
+=> 606548
 
 LinuxStat::Memory.percent_available
-=> 10.52
+=> 15.81
 
 LinuxStat::Memory.percent_used
-=> 89.48
+=> 84.19
 
 LinuxStat::Memory.stat
-=> {:total=>3836264, :used=>3432540, :available=>403724, :percent_used=>89.48, :percent_available=>10.52}
+=> {:total=>3836256, :used=>3229708, :available=>606548, :percent_used=>84.19, :percent_available=>15.81}
 
 LinuxStat::Memory.total
-=> 3836264
+=> 3836256
 
 LinuxStat::Memory.used
-=> 3432540
+=> 3229708
 
 ```
 
 ### LinuxStat::Mounts
 ```
 LinuxStat::Mounts.list
-=> ["proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0", "sys /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0", "dev /dev devtmpfs rw,nosuid,relatime,size=1891796k,nr_inodes=472949,mode=755 0 0", "run /run tmpfs rw,nosuid,nodev,relatime,mode=755 0 0", "...
+=> ["proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0", "sys /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0", "dev /dev devtmpfs rw,nosuid,relatime,size=1891804k,nr_inodes=472951,mode=755 0 0", "run /run tmpfs rw,nosuid,nodev,relatime,mode=755 0 0", "...
 
 LinuxStat::Mounts.root
 => "/dev/sda2"
@@ -205,14 +214,14 @@ LinuxStat::Mounts.root_mount_options
 => "rw,noatime,attr2,inode64,logbufs=8,logbsize=32k,noquota"
 
 LinuxStat::Mounts.tmpfs
-=> {"/dev/shm"=>"tmpfs /dev/shm tmpfs rw,nosuid,nodev 0 0", "/sys/fs/cgroup"=>"tmpfs /sys/fs/cgroup tmpfs ro,nosuid,nodev,noexec,size=4096k,nr_inodes=1024,mode=755 0 0", "/ramdisk"=>"tmpfs /ramdisk tmpfs rw,nosuid,nodev,relatime,size=6291456k 0 0", "/tmp...
+=> {"/dev/shm"=>"tmpfs /dev/shm tmpfs rw,nosuid,nodev 0 0", "/sys/fs/cgroup"=>"tmpfs /sys/fs/cgroup tmpfs ro,nosuid,nodev,noexec,size=4096k,nr_inodes=1024,mode=755 0 0", "/cache"=>"tmpfs /cache tmpfs rw,nosuid,nodev,relatime,size=2097152k 0 0", "/ramdisk...
 
 ```
 
 ### LinuxStat::Net
 ```
 LinuxStat::Net.ipv4_private
-=> "192.168.0.106"
+=> "192.168.0.101"
 
 ```
 
@@ -230,33 +239,39 @@ LinuxStat::OS.hostname
 LinuxStat::OS.lsb_release
 => {:LSB_VERSION=>"1.4", :DISTRIB_ID=>"Arch", :DISTRIB_RELEASE=>"rolling", :DISTRIB_DESCRIPTION=>"Arch Linux"}
 
+LinuxStat::OS.machine
+=> "x86_64"
+
+LinuxStat::OS.nodename
+=> "archlinux"
+
 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/"...
 
 LinuxStat::OS.uptime
-=> {:hour=>10, :minute=>54, :second=>22.45}
+=> {:hour=>9, :minute=>10, :second=>19.41}
 
 ```
 
 ### LinuxStat::Process
 ```
 LinuxStat::Process.count
-=> 210
+=> 221
 
 LinuxStat::Process.idle
-=> [3, 4, 6, 9, 12, 23, 30, 37, 39, 49, 102, 103, 104, 106, 107, 108, 109, 110, 117, 118, 119, 122, 131, 134, 140, 152, 153, 179, 181, 183, 184, 191, 192, 193, 194, 195, 196, 198, 236, 286, 314, 324, 346, 385, 3540, 3541, 3542, 3543, 3544, 3545, 30463, 3...
+=> [3, 4, 6, 9, 12, 23, 30, 37, 39, 49, 102, 103, 104, 106, 107, 108, 109, 110, 117, 118, 120, 122, 131, 134, 140, 152, 153, 168, 170, 173, 174, 182, 183, 184, 185, 186, 187, 214, 224, 268, 308, 313, 314, 330, 2357, 2358, 2359, 2360, 2361, 2362, 25094, 2...
 
 LinuxStat::Process.list
-=> [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 46, 47, 48, 49, 50, 51, 52, 102, 103, 104, 106, 107, 108, 109, 110, 112, 114, 115, 117, 118, 119, 122, 131, 134,...
+=> [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 46, 47, 48, 49, 50, 51, 52, 102, 103, 104, 106, 107, 108, 109, 110, 112, 114, 115, 117, 118, 120, 122, 131, 134,...
 
 LinuxStat::Process.names
-=> {1=>"systemd", 2=>"kthreadd", 3=>"rcu_gp", 4=>"rcu_par_gp", 6=>"kworker/0:0H-events_highpri", 9=>"mm_percpu_wq", 10=>"ksoftirqd/0", 11=>"rcuc/0", 12=>"rcu_preempt", 13=>"rcub/0", 14=>"migration/0", 15=>"idle_inject/0", 16=>"cpuhp/0", 17=>"cpuhp/1", 18...
+=> {1=>"systemd", 2=>"kthreadd", 3=>"rcu_gp", 4=>"rcu_par_gp", 6=>"kworker/0:0H-kblockd", 9=>"mm_percpu_wq", 10=>"ksoftirqd/0", 11=>"rcuc/0", 12=>"rcu_preempt", 13=>"rcub/0", 14=>"migration/0", 15=>"idle_inject/0", 16=>"cpuhp/0", 17=>"cpuhp/1", 18=>"idle...
 
 LinuxStat::Process.running
-=> [33736]
+=> [30804]
 
 LinuxStat::Process.sleeping
-=> [1, 2, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 25, 26, 27, 28, 31, 32, 33, 34, 35, 38, 40, 41, 42, 46, 47, 48, 50, 51, 52, 112, 114, 115, 178, 180, 197, 225, 239, 309, 317, 329, 332, 333, 334, 338, 367, 368, 369, 370, 378, 381, 383, 384, 402,...
+=> [1, 2, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 25, 26, 27, 28, 31, 32, 33, 34, 35, 38, 40, 41, 42, 46, 47, 48, 50, 51, 52, 112, 114, 115, 167, 169, 188, 215, 228, 307, 309, 311, 316, 317, 319, 320, 354, 355, 356, 357, 364, 368, 370, 384, 397,...
 
 LinuxStat::Process.types
 => {1=>:sleeping, 2=>:sleeping, 3=>:idle, 4=>:idle, 6=>:idle, 9=>:idle, 10=>:sleeping, 11=>:sleeping, 12=>:idle, 13=>:sleeping, 14=>:sleeping, 15=>:sleeping, 16=>:sleeping, 17=>:sleeping, 18=>:sleeping, 19=>:sleeping, 20=>:sleeping, 21=>:sleeping, 23=>:i...
@@ -266,31 +281,118 @@ LinuxStat::Process.zombie
 
 ```
 
+### LinuxStat::ProcessInfo
+```
+LinuxStat::ProcessInfo.cmdline
+=> "ruby bin/linuxstat.rb -md"
+
+LinuxStat::ProcessInfo.command_name
+=> "ruby"
+
+LinuxStat::ProcessInfo.cpu_stat
+=> {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>2}
+
+LinuxStat::ProcessInfo.cpu_usage
+=> 0.0
+
+LinuxStat::ProcessInfo.last_executed_cpu
+=> 2
+
+LinuxStat::ProcessInfo.mem_stat
+=> {:memory=>9644, :virtual_memory=>79568, :resident_memory=>15764}
+
+LinuxStat::ProcessInfo.memory
+=> 9644
+
+LinuxStat::ProcessInfo.resident_memory
+=> 15764
+
+LinuxStat::ProcessInfo.threads
+=> 1
+
+LinuxStat::ProcessInfo.total_io
+=> {:read_bytes=>0, :write_bytes=>0}
+
+LinuxStat::ProcessInfo.virtual_memory
+=> 79568
+
+```
+
 ### LinuxStat::Swap
 ```
 LinuxStat::Swap.any?
 => true
 
 LinuxStat::Swap.available
-=> 1913936
+=> 2256212
 
 LinuxStat::Swap.list
-=> {"/dev/zram0"=>[:partition, 4194300, 2280364, -2]}
+=> {"/dev/zram0"=>[:partition, 4194300, 1938088, -2]}
 
 LinuxStat::Swap.percent_available
-=> 45.63
+=> 53.79
 
 LinuxStat::Swap.percent_used
-=> 54.37
+=> 46.21
 
 LinuxStat::Swap.stat
-=> {:total=>4194300, :used=>2280364, :available=>1913936, :percent_used=>54.37, :percent_available=>45.63}
+=> {:total=>4194300, :used=>1938088, :available=>2256212, :percent_used=>46.21, :percent_available=>53.79}
 
 LinuxStat::Swap.total
 => 4194300
 
 LinuxStat::Swap.used
-=> 2280364
+=> 1938088
+
+```
+
+### LinuxStat::Sysconf
+```
+LinuxStat::Sysconf.child_max
+=> 2000000
+
+LinuxStat::Sysconf.hostname_max
+=> 64
+
+LinuxStat::Sysconf.login_name_max
+=> 256
+
+LinuxStat::Sysconf.open_max
+=> 8192
+
+LinuxStat::Sysconf.page_size_max
+=> 4096
+
+LinuxStat::Sysconf.posix_version
+=> 200809
+
+LinuxStat::Sysconf.sc_clk_tck
+=> 100
+
+LinuxStat::Sysconf.stream_max
+=> 16
+
+LinuxStat::Sysconf.tty_name_max
+=> 32
+
+```
+
+### LinuxStat::Uname
+```
+LinuxStat::Uname.machine
+=> "x86_64"
+
+LinuxStat::Uname.nodename
+=> "archlinux"
+
+LinuxStat::Uname.release
+=> "5.9.1-xanmod1-1"
+
+LinuxStat::Uname.sysname
+=> "Linux"
+
+LinuxStat::Uname.version
+=> "#1 SMP PREEMPT Wed, 21 Oct 2020 01:11:20 +0000"
 
 ```
 

data/bin/linuxstat.rb

@@ -29,6 +29,7 @@ execute.sort.each do |c|
 	next if e.class != Module && e.class != Class
 
 	meths = e.methods(false).sort
+	next if meths.any? { |a| e.method(a).arity > 0 }
 
 	if meths.length > 0
 		if MARKDOWN

data/ext/fs_stat/fs_stat.c

@@ -25,6 +25,7 @@ static VALUE statfs(VALUE obj, VALUE dir) {
 }
 
 void Init_fs_stat() {
-	VALUE fs = rb_define_module("FS") ;
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE fs = rb_define_module_under(_linux_stat, "FS") ;
 	rb_define_module_function(fs, "stat", statfs, 1) ;
 }

data/ext/sysconf/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+unless (have_header('sys/unistd.h') && have_header('ruby.h'))
+	abort('Missing header')
+end
+
+create_makefile 'linux_stat/sysconf'

data/ext/sysconf/sysconf.c

@@ -0,0 +1,53 @@
+#include <unistd.h>
+#include "ruby.h"
+
+static VALUE getTick(VALUE obj) {
+	return INT2FIX(sysconf(_SC_CLK_TCK)) ;
+}
+
+static VALUE getChildMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_CHILD_MAX)) ;
+}
+
+static VALUE getHostnameMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_HOST_NAME_MAX)) ;
+}
+
+static VALUE getLoginNameMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_LOGIN_NAME_MAX)) ;
+}
+
+static VALUE getOpenMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_OPEN_MAX)) ;
+}
+
+static VALUE getPageSizeMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_PAGESIZE)) ;
+}
+
+static VALUE getStreamMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_STREAM_MAX)) ;
+}
+
+static VALUE getTTYNameMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_TTY_NAME_MAX)) ;
+}
+
+static VALUE getPosixVersion(VALUE obj) {
+	return INT2FIX(sysconf(_SC_VERSION)) ;
+}
+
+void Init_sysconf() {
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _sysconf = rb_define_module_under(_linux_stat, "Sysconf") ;
+
+	rb_define_module_function(_sysconf, "sc_clk_tck", getTick, 0) ;
+	rb_define_module_function(_sysconf, "child_max", getChildMax, 0) ;
+	rb_define_module_function(_sysconf, "hostname_max", getHostnameMax, 0) ;
+	rb_define_module_function(_sysconf, "login_name_max", getLoginNameMax, 0) ;
+	rb_define_module_function(_sysconf, "open_max", getOpenMax, 0) ;
+	rb_define_module_function(_sysconf, "page_size_max", getPageSizeMax, 0) ;
+	rb_define_module_function(_sysconf, "stream_max", getStreamMax, 0) ;
+	rb_define_module_function(_sysconf, "tty_name_max", getTTYNameMax, 0) ;
+	rb_define_module_function(_sysconf, "posix_version", getPosixVersion, 0) ;
+}

data/ext/utsname/utsname.c

@@ -10,9 +10,9 @@ void init_buf() {
 	status = uname(&buf) ;
 }
 
-static VALUE getMachine(VALUE obj) {
-	VALUE machine = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.machine) ;
-	return machine ;
+static VALUE getSysname(VALUE obj) {
+	VALUE sysname = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.sysname) ;
+	return sysname ;
 }
 
 static VALUE getNodename(VALUE obj) {
@@ -20,10 +20,30 @@ static VALUE getNodename(VALUE obj) {
 	return nodename ;
 }
 
+static VALUE getRelease(VALUE obj) {
+	VALUE release = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.release) ;
+	return release ;
+}
+
+static VALUE getVersion(VALUE obj) {
+	VALUE version = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.version) ;
+	return version ;
+}
+
+static VALUE getMachine(VALUE obj) {
+	VALUE machine = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.machine) ;
+	return machine ;
+}
+
 void Init_utsname() {
 	init_buf() ;
 
-	VALUE _uname = rb_define_module("Uname") ;
-	rb_define_module_function(_uname, "machine", getMachine, 0) ;
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _uname = rb_define_module_under(_linux_stat, "Uname") ;
+
+	rb_define_module_function(_uname, "sysname", getSysname, 0) ;
 	rb_define_module_function(_uname, "nodename", getNodename, 0) ;
+	rb_define_module_function(_uname, "release", getRelease, 0) ;
+	rb_define_module_function(_uname, "version", getVersion, 0) ;
+	rb_define_module_function(_uname, "machine", getMachine, 0) ;
 }

data/lib/linux_stat.rb

@@ -2,7 +2,6 @@ require "linux_stat/version"
 require "linux_stat/battery"
 require "linux_stat/bios"
 require "linux_stat/cpu"
-require "linux_stat/kernel"
 require "linux_stat/memory"
 require "linux_stat/net"
 
@@ -15,3 +14,7 @@ require "linux_stat/mounts"
 
 require "linux_stat/fs_stat"
 require "linux_stat/filesystem"
+
+require "linux_stat/sysconf"
+require "linux_stat/kernel"
+require "linux_stat/process_info"

data/lib/linux_stat/battery.rb

@@ -9,7 +9,7 @@ module LinuxStat
 			end
 
 			# Returns the details of the battery.
-			#If the battery is not present it will return an empty Hash.
+			# If the battery is not present it will return an empty Hash.
 			def stat
 				st = status.downcase
 				return {} unless present?
@@ -27,7 +27,7 @@ module LinuxStat
 			end
 
 			# Returns the model of the battery.
-			#If the battery is not present or the information isn't available it will return an empty String.
+			# If the battery is not present or the information isn't available it will return an empty String.
 			def model
 				return ''.freeze unless model_readable?
 				IO.read(File.join(PATH, 'model_name')).tap(&:strip!)

data/lib/linux_stat/bios.rb

@@ -3,9 +3,10 @@ module LinuxStat
 		class << self
 			# Returns the model of the BIOS.
 			# If the information is not available it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def model
-				# Cached ; as changing the value in runtime is unexpected
+				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@model ||= if File.readable?('/sys/devices/virtual/dmi/id/product_name')
 					IO.read('/sys/devices/virtual/dmi/id/product_name').tap(&:strip!)
 				elsif File.readable?('/sys/firmware/devicetree/base/model')
@@ -17,9 +18,10 @@ module LinuxStat
 
 			# Returns the vendor of the BIOS.
 			# If the information is not available it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def vendor
-				# Cached ; as changing the value in runtime is unexpected
+				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@vendor ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_vendor')
 					IO.read('/sys/devices/virtual/dmi/id/bios_vendor').tap(&:strip!)
 				else
@@ -29,7 +31,8 @@ module LinuxStat
 
 			# Returns the version of the BIOS.
 			# If the information is not available it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def version
 				@@version ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_version')
 					IO.read('/sys/devices/virtual/dmi/id/bios_version').tap(&:strip!)
@@ -40,7 +43,8 @@ module LinuxStat
 
 			# Returns the date of the BIOS.
 			# If the information is not available it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def date
 				@@date ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_date')
 					IO.read('/sys/devices/virtual/dmi/id/bios_date').tap(&:strip!)

data/lib/linux_stat/cpu.rb

@@ -19,7 +19,14 @@ module LinuxStat
 				sleep(sleep)
 				data2 = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
 
-				data.size.times.reduce({}) do |h, x|
+				# On devices like android, the core count can change anytime.
+				# 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
+
+				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)
 
@@ -63,7 +70,8 @@ module LinuxStat
 
 			# Returns the model of processor.
 			# If the information isn't available, it will return en empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def model
 				@@name ||= cpuinfo.find { |x| x.start_with?('model name') }.to_s.split(?:)[-1].to_s.strip
 			end

data/lib/linux_stat/filesystem.rb

@@ -1,7 +1,5 @@
 module LinuxStat
 	module Filesystem
-		prepend FS
-
 		class << self
 			# stat(fs = '/')
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
@@ -12,7 +10,7 @@ module LinuxStat
 			# 3. used space (in kilobytes)
 			#
 			# In a hash format:
-			# {:total=>119981191168, :free=>43155574784, :used=>76825616384, :available=>43155574784}
+			#    {:total=>119981191168, :free=>43155574784, :used=>76825616384, :available=>43155574784}
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
 			def stat(fs = ?/.freeze)
@@ -23,7 +21,7 @@ module LinuxStat
 				{
 					total: s[:block_size] * s[:blocks],
 					free: s[:block_size] * s[:block_free],
-					used: s[:blocks].-(s[:block_free]) * s[:block_size],
+					used: s[:blocks].-(s[:block_free]) * s[:block_size]
 				}
 			end
 
@@ -83,11 +81,11 @@ module LinuxStat
 			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
 			#
 			# It returns a Hash with the following data (for example):
-			# {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10535967, :block_avail_unpriv=>10535967, :inodes=>58612160, :free_inodes=>56718550, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
+			#    {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10535967, :block_avail_unpriv=>10535967, :inodes=>58612160, :free_inodes=>56718550, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
 			#
 			# If the stat can't be acquired, this method will return an empty Hash.
-			def stat_raw(fs = '/'.freeze)
-				FS.stat(fs)
+			def stat_raw(fs = ?/.freeze)
+				LinuxStat::FS.stat(fs)
 			end
 		end
 	end

data/lib/linux_stat/kernel.rb

@@ -3,7 +3,7 @@ module LinuxStat
 		class << self
 			# Returns the Linux Kernel version.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def version
 				return ''.freeze if string.empty?
 				@@version ||= splitted[2]
@@ -11,7 +11,7 @@ module LinuxStat
 
 			# Returns the name of the user who built the kernel using KBUILD_FLAGS.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def build_user
 				@@build_user ||= string.split(/(\(.+\))/).each(&:strip!)
 					.reject(&:empty?).find { |x| x[/^\(.+\)$/] }.to_s
@@ -20,7 +20,7 @@ module LinuxStat
 
 			# Returns the compiler used to compile the Linux Kernel.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def compiler
 				return ''.freeze if string.empty?
 
@@ -39,7 +39,7 @@ module LinuxStat
 
 			# Returns the compiler version used to compile the Linux Kernel.
 			# If the information isn't available, it will return a frozen empty string.
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def compiler_version
 				@@compiler_version ||= string.split(/(\(.+?\))/).each(&:strip!)
 					.reject(&:empty?)[2..4].to_a
@@ -62,7 +62,7 @@ module LinuxStat
 			# You have to use regexp yourself to get the proper zone.
 			# Use LinuxStat::Kernel.build_date_string to get the original string if you need that.
 			#
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached  (memoized) ; as changing the value in runtime is unexpected.
 			def build_date
 				return nil if splitted.empty?
 
@@ -107,7 +107,7 @@ module LinuxStat
 			# You have to use regexp yourself to get the proper zone.
 			# Use LinuxStat::Kernel.build_date_string to get the original string if you need that.
 			#
-			# The output is also cached ; as changing the value in runtime is unexpected.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def build_date_string
 				return nil if splitted.empty?
 
@@ -141,6 +141,15 @@ module LinuxStat
 				@@string ||= File.readable?('/proc/version') ? IO.read('/proc/version', 1024).tap(&:strip!) : ''
 			end
 
+			# Returns the sc_clk_tck or the same output from command `getconf CLK_TCK`.
+			# Also, clk_tck is an alias of this method.
+			# The output is also cached ; as changing the value in runtime is unexpected.
+			def ticks
+				@@tick ||= LinuxStat::Sysconf.sc_clk_tck
+			end
+
+			alias clk_tck ticks
+
 			private
 			def splitted
 				@@string_splitted ||= string.split

data/lib/linux_stat/memory.rb

@@ -2,9 +2,10 @@ module LinuxStat
 	module Memory
 		class << self
 			# Returns the memory details reported by /proc/meminfo. In this format:
-			# {:total=>3836264, :used=>3097952, :available=>738312, :percent_used=>80.75, :percent_available=>19.25}
+			#    {:total=>3836264, :used=>3097952, :available=>738312, :percent_used=>80.75, :percent_available=>19.25}
+			#
+			# The values are in Kilobyte.
 			#
-			# The value is in Kilobyte.
 			# If the statistics is not available, it will return an empty Hash.
 			def stat
 				return {} unless meminfo?
@@ -31,6 +32,7 @@ module LinuxStat
 
 			# Returns the total memory details reported by /proc/meminfo.
 			# The value is in Kilobyte.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil.
 			def total
 				return nil unless meminfo?
@@ -39,6 +41,7 @@ module LinuxStat
 
 			# Returns the total memory details reported by /proc/meminfo.
 			# The value is in Kilobyte.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil
 			def available
 				return nil unless meminfo?
@@ -47,6 +50,7 @@ module LinuxStat
 
 			# Returns the amount of memory used reported by /proc/meminfo.
 			# The value is in Kilobyte.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil.
 			def used
 				return nil unless meminfo?
@@ -55,6 +59,7 @@ module LinuxStat
 			end
 
 			# Returns the percentage of memory used reported by /proc/meminfo.
+			#
 			# It retuns an Integer but if the info is not available, it will return nil
 			def percent_used
 				return nil unless meminfo?
@@ -64,6 +69,7 @@ module LinuxStat
 			end
 
 			# Returns the percentage of memory used reported by /proc/meminfo.
+			#
 			# It retuns an Integer but if the info is not available,  it will return nil
 			def percent_available
 				return nil unless meminfo?

data/lib/linux_stat/os.rb

@@ -1,10 +1,8 @@
 module LinuxStat
 	module OS
-		prepend Uname
-
 		class << self
 			# Reads /etc/os-release and returns a Hash. For example:
-			# {: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.
 			#
@@ -13,12 +11,12 @@ module LinuxStat
 			# The information is also cached, and once loaded, won't change in runtime. Because changing the /etc/lsb-release
 			# isn't expected in runtime.
 			def os_release
-				# Cached ; as changing the value in runtime is unexpected
+				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@os_release ||= File.readable?('/etc/os-release') ? release('/etc/os-release') : {}
 			end
 
 			# Reads /etc/lsb-release and returns a Hash. For example:
-			# {:LSB_VERSION=>"1.4", :DISTRIB_ID=>"Arch", :DISTRIB_RELEASE=>"rolling", :DISTRIB_DESCRIPTION=>"Arch Linux"}
+			#    {:LSB_VERSION=>"1.4", :DISTRIB_ID=>"Arch", :DISTRIB_RELEASE=>"rolling", :DISTRIB_DESCRIPTION=>"Arch Linux"}
 			#
 			# If the info isn't available, it will return an empty Hash.
 			#
@@ -27,12 +25,13 @@ module LinuxStat
 			# The information is also cached, and once loaded, won't change in runtime. Because changing the /etc/lsb-release
 			# isn't expected in runtime.
 			def lsb_release
-				# Cached ; as changing the value in runtime is unexpected
+				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@lsb_release ||= File.readable?('/etc/lsb-release') ? release('/etc/lsb-release') : {}
 			end
 
 			# Reads /etc/lsb-release or /etc/os-release tries to get information about the distribution.
 			# If the information isn't available, it will read and return /etc/issue.
+			#
 			# The return type is String.
 			# If none of the info is available, it will return an empty frozen String.
 			def distribution
@@ -54,18 +53,21 @@ module LinuxStat
 			end
 
 			# Uses utsname.h to determine the machine
+			#
 			# It returns a String but if the info isn't available, it will return an empty String
 			def machine
-				@@machine ||= Uname.machine
+				@@machine ||= LinuxStat::Uname.machine
 			end
 
 			# Uses utsname.h to determine the system nodename
+			#
 			# It returns String but if the info isn't available, it will return an empty String
 			def nodename
-				@@nodename ||= Uname.nodename
+				@@nodename ||= LinuxStat::Uname.nodename
 			end
 
 			# Reads /etc/hostname and returns the hostname.
+			#
 			# The return type is String.
 			# If the info info isn't available, it will return 'localhost'.
 			def hostname
@@ -90,7 +92,7 @@ module LinuxStat
 			end
 
 			# Reads /proc/uptime and returns the system uptime:
-			# {:hour=>10, :minute=>34, :second=>12.59}
+			#    {:hour=>10, :minute=>34, :second=>12.59}
 			#
 			# If the stat isn't available, an empty hash is returned.
 			def uptime

data/lib/linux_stat/process_info.rb

@@ -0,0 +1,310 @@
+module LinuxStat
+	module ProcessInfo
+		class << self
+			# total_io(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the total read/write caused by a process.
+			# The output is Hash. For example, a sample output:
+			#    {:read_bytes=>0, :write_bytes=>0}
+			#
+			# The output is only based on the total disk IO the process has done.
+			#
+			# If the info isn't available it will return an empty Hash.
+			def total_io(pid = $$)
+				return {} unless File.readable?("/proc/#{pid}/io".freeze)
+				out = {}
+
+				IO.readlines("/proc/#{pid}/io".freeze).each { |x|
+					x.strip!
+
+					if x[/^(read|write)_bytes:\s*\d*$/]
+						splitted = x.split
+						out.merge!(splitted[0].split(?:)[0].to_sym => splitted[-1].to_i)
+					end
+				}
+
+				out
+			end
+
+			# cmdline(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the total command of the process.
+			# The output is String. For example, a sample output:
+			#    "ruby -r linux_stat -e p LinuxStat::ProcessInfo.cmdline"
+			#
+			# If the info isn't available it will return an empty frozen String.
+			def cmdline(pid = $$)
+				file = "/proc/#{pid}/cmdline".freeze
+				return ''.freeze unless File.readable?(file)
+
+				_cmdline = IO.read(file)
+				_cmdline.gsub!(?\u0000, ?\s)
+				_cmdline.tap(&:strip!)
+			end
+
+			# command_name(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the total command name of the process.
+			# The output is String. For example, a sample output:
+			#    "ruby"
+			#
+			# If the info isn't available it will return an empty frozen String.
+			def command_name(pid = $$)
+				# Do note that the /proc/ppid/comm may not contain the full name
+				file = "/proc/#{pid}/cmdline".freeze
+				return ''.freeze unless File.readable?(file)
+
+				_cmdline = IO.read(file)
+				_cmdline.gsub!(?\u0000, ?\s)
+				File.split(_cmdline.tap(&:strip!).split[0])[-1]
+			end
+
+			# mem_stat(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the memory, virtual memory, and resident memory of the process.
+			# All values are in Kilobytes.
+			#
+			# The output is a Hash. For example, a sample output:
+			#    {:memory=>8656, :virtual_memory=>78272, :resident_memory=>14072}
+			#
+			# Note:
+			# If you need only memory usage of a process, run LinuxStat::ProcessInfo.memory(pid)
+			# If you need only virtual memory for a process, run LinuxStat::ProcessInfo.virtual_memory(pid)
+			# If you need only resident memory of a process, run LinuxStat::ProcessInfo.resident_memory(pid)
+			#
+			# This method opens opens multiple files.
+			# But if you need all of the info, then running this method once is efficient.
+			#
+			# If the info isn't available it will return an empty Hash.
+			def mem_stat(pid = $$)
+				stat_file = "/proc/#{pid}/stat".freeze
+				status_file = "/proc/#{pid}/status".freeze
+
+				stat = if File.readable?(stat_file)
+					IO.read(stat_file).split
+				else
+					[]
+				end
+
+				status = if File.readable?(status_file)
+					IO.readlines(status_file)
+				else
+					[]
+				end
+
+				_rss_anon = status.find { |x| x.start_with?('RssAnon') }
+				rss_anon = _rss_anon ? _rss_anon.split[1].to_i : nil
+
+				_virtual_memory = stat[22]
+				vm = _virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
+
+				_vm_rss = status.find { |x| x.start_with?('VmRSS') }
+				vm_rss = _vm_rss ? _vm_rss.split[1].to_i : nil
+
+				{
+					memory: rss_anon,
+					virtual_memory: vm,
+					resident_memory: vm_rss
+				}
+			end
+
+			# memory(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the memory of the process.
+			# The value is in Kilobytes.
+			# The output is an Integer. For example, a sample output:
+			#    8664
+			#
+			# If the info isn't available it will return nil.
+			def memory(pid = $$)
+				_rss_anon = IO.readlines("/proc/#{pid}/status")
+					.find { |x| x.start_with?('RssAnon') }
+
+				_rss_anon ? _rss_anon.split[1].to_i : nil
+			end
+
+			# virtual_memory(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the virtual memory for the process.
+			# The value is in Kilobytes.
+			# The output is an Integer. For example, a sample output:
+			#    78376
+			#
+			# If the info isn't available it will return nil.
+			def virtual_memory(pid = $$)
+				_virtual_memory = IO.read("/proc/#{pid}/stat".freeze).split[22]
+				_virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
+			end
+
+			# resident_memory(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the resident memory for the process.
+			# The value is in Kilobytes.
+			# The output is an Integer. For example, a sample output:
+			#    14012
+			#
+			# If the info isn't available it will return nil.
+			def resident_memory(pid = $$)
+				_vm_rss = IO.readlines("/proc/#{pid}/status")
+					.find { |x| x.start_with?('VmRSS') }
+
+				_vm_rss ? _vm_rss.split[1].to_i : nil
+			end
+
+			# cpu_stat(pid: $$, sleep: 0.05)
+			# 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 0.05
+			#
+			# Note 1:
+			# Do note that the sleep time can slow down your application.
+			# And it's only needed for the cpu usage calculation.
+			#
+			# It retuns the CPU usage, threads, and the last executed CPU in Hash.
+			# For example:
+			#    {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>1}
+			#
+			# But if the info isn't available, it will return an empty Hash.
+			#
+			# The :cpu_usage is in percentage. It's also divided with the number
+			# of CPU. :cpu_usage for example, will return 25.0 if the CPU count
+			# is 4, and the process is using 100% of a thread / core.
+			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# The :threads returns the number of threads for the process.
+			# The value is a Integer.
+			#
+			# Note 2:
+			# If you just need the CPU usage run LinuxStat::ProcessInfo.cpu_usage(pid = $$)
+			# If you just need the threads run LinuxStat::ProcessInfo.threads(pid = $$)
+			# If you just need the last executed CPU run LinuxStat::ProcessInfo.last_executed_cpu(pid = $$)
+			# Running this method is slower and it opens multiple files at once
+			#
+			# 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: 0.05)
+				file = "/proc/#{pid}/stat"
+				return {} unless File.readable?(file)
+
+				ticks = get_ticks
+
+				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)
+				stat = IO.read(file).split
+
+				utime2, stime2, starttime2 = stat.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)
+				cpu = totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+
+				{
+					cpu_usage: cpu,
+					threads: stat[19].to_i,
+					last_executed_cpu: stat[38].to_i
+				}
+			end
+
+			# cpu_usage(pid: $$, sleep: 0.05)
+			# 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 0.05
+			#
+			# It retuns the CPU usage in Float.
+			# For example:
+			#    10.0
+			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# 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: 0.05)
+				file = "/proc/#{pid}/stat"
+				return nil unless File.readable?(file)
+
+				ticks = get_ticks
+
+				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)
+
+				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)
+			end
+
+			# threads(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the threads for the current process in Integer.
+			# For example:
+			#    1
+			# But if the info isn't available, it will return nil.
+			#
+			# 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)
+
+				IO.read(file).split[19].to_i
+			end
+
+			# last_executed_cpu(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the last executed CPU in Integer.
+			# For example:
+			#    2
+			# But if the info isn't available, it will return nil.
+			#
+			# 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)
+
+				IO.read("/proc/#{pid}/stat".freeze).split[38].to_i
+			end
+
+			private
+			def get_ticks
+				@@ticks ||= Sysconf.sc_clk_tck
+			end
+		end
+	end
+end

data/lib/linux_stat/swap.rb

@@ -21,6 +21,7 @@ module LinuxStat
 
 			# Show aggregated used and available swap.
 			# The values are in kilobytes.
+			#
 			# The return type is Hash.
 			# If the info isn't available, the return type is an empty Hash.
 			def stat
@@ -44,6 +45,7 @@ module LinuxStat
 
 			# Show total amount of swap.
 			# The value is in kilobytes.
+			#
 			# The return type is a Integer but if the info isn't available, it will return nil.
 			def total
 				return nil unless swaps_readable?
@@ -52,6 +54,7 @@ module LinuxStat
 
 			# Show total amount of available swap.
 			# The value is in kilobytes.
+			#
 			# The return type is a Integer but if the info isn't available, it will return nil.
 			def available
 				return nil unless swaps_readable?
@@ -61,6 +64,7 @@ module LinuxStat
 
 			# Show total amount of used swap.
 			# The value is in kilobytes.
+			#
 			# The return type is a Integer but if the info isn't available, it will return nil.
 			def used
 				return nil unless swaps_readable?
@@ -79,7 +83,8 @@ module LinuxStat
 				values_t[-1].sum.*(100).fdiv(total).round(2)
 			end
 
-			# Show percentage of swap available.
+			# Shows the percentage of swap available.
+			#
 			# The return type is a Float but if the info isn't available, it will return nil.
 			def percent_available
 				return nil unless swaps_readable?

data/lib/linux_stat/version.rb

@@ -1,3 +1,3 @@
 module LinuxStat
-	VERSION = "0.3.3"
+	VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linux_stat
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Sourav Goswami
@@ -15,8 +15,9 @@ email:
 - souravgoswami@protonmail.com
 executables: []
 extensions:
-- ext/utsname/extconf.rb
 - ext/fs_stat/extconf.rb
+- ext/sysconf/extconf.rb
+- ext/utsname/extconf.rb
 extra_rdoc_files:
 - README.md
 files:
@@ -26,6 +27,8 @@ files:
 - bin/setup
 - ext/fs_stat/extconf.rb
 - ext/fs_stat/fs_stat.c
+- ext/sysconf/extconf.rb
+- ext/sysconf/sysconf.c
 - ext/utsname/extconf.rb
 - ext/utsname/utsname.c
 - lib/linux_stat.rb
@@ -39,6 +42,7 @@ files:
 - lib/linux_stat/net.rb
 - lib/linux_stat/os.rb
 - lib/linux_stat/process.rb
+- lib/linux_stat/process_info.rb
 - lib/linux_stat/swap.rb
 - lib/linux_stat/version.rb
 homepage: https://github.com/Souravgoswami/linux_stat/