linux_stat 0.6.5 → 0.8.0

data/exe/linuxstat.rb

@@ -7,6 +7,46 @@ rescue LoadError
 	abort "The Gem needs to be installed before this test can be run!"
 end
 
+# Gradient colour to strings
+class String
+	def colourize(colour = 1, flip: false)
+		colours, line_length = [], -1
+		temp = ''
+
+		each_line do |c|
+			n, i = c.length, -1
+
+			if line_length != n
+				step, line_length = 255.0./(n), n
+				colours.clear
+
+				while (i += 1) < n
+					l = i.*(step)
+					colours.<<(
+						case colour
+							when 0 then [ l.*(2).to_i.clamp(0, 255), l.to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255) ]
+							when 1 then [ 255, 255.-(l).to_i.clamp(0, 255), l.to_i.clamp(0, 255) ]
+							when 2 then [ l.to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), l.to_i.clamp(0, 255) ]
+							when 3 then [ l.*(2).to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), 100.+(l / 2).to_i.clamp(0, 255) ]
+							when 4 then [ 30, 255.-(l / 2).to_i.clamp(0, 255), 110.+(l / 2).to_i.clamp(0, 255) ]
+							when 5 then [ 255.-(l * 2).to_i.clamp(0, 255), l.to_i.clamp(0, 255), 200 ]
+							when 6 then [ 50.+(255 - l).to_i.clamp(0, 255), 255.-(l / 2).to_i.clamp(0, 255), (l * 2).to_i.clamp(0, 255) ]
+							else [ l.*(2).to_i.clamp(0, 255), 255.-(l).to_i.clamp(0, 255), 100.+(l / 2).to_i.clamp(0, 255) ]
+						end
+					)
+				end
+
+				colours.reverse! if flip
+			end
+
+			i = -1
+			temp.concat "\e[38;2;#{colours[i][0]};#{colours[i][1]};#{colours[i][2]}m#{c[i]}" while (i += 1) < n
+		end
+
+		temp << "\e[0m".freeze
+	end
+end
+
 # Check which conflicting argument (e.g., `-md -html` together) is passed last
 # Always use the last argument
 conflicting, hash = [
@@ -54,7 +94,6 @@ 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
@@ -67,20 +106,68 @@ execute.sort.each do |c|
 	end
 
 	meths.each do |meth|
+		arg = nil
+		params = e.method(meth).parameters
+
+		param = ''
+
+		params.each do |p|
+			case p[0]
+				when :opt
+					param << "#{p[1]}, "
+				when :key
+					param << "#{p[1]}:, "
+				when :req
+					param << "#{p[1] || 'arg'}, "
+			end
+		end
+
+		param.delete_suffix!(", ")
+
+		if e.method(meth).arity > 0
+			if c == :PrettifyBytes
+				arg = rand(10 ** 15)
+			elsif c == :FS
+				arg = '/'
+			else
+				next
+			end
+		end
+
+		disp_meth = "#{meth}"
+		disp_meth.concat(arg ? "(#{param} = #{arg.inspect})" : "(#{param})")
+
 		time = Time.now
-		v = e.send(meth)
+		v = arg ? e.send(meth, arg) : e.send(meth)
 		time2 = Time.now
 		time = time2.-(time).*(1_000_000).round(3)
 
 		v = v.inspect
 		dis = v.length > 253 ? v[0..250].strip + '...'.freeze : v
 
+		source = e.singleton_method(meth).source_location.to_a
+		src, src_meth = '', ''
+
+		unless source.empty?
+			src << " File: #{File.split(source[0])[-1]} | Line: #{source[1]}\n"
+			src_meth << " Definition: #{IO.foreach(source[0]).first(source[1])[-1].strip}\n"
+
+			if MARKDOWN || HTML
+				src.prepend('#'.freeze)
+				src_meth.prepend('#'.freeze)
+			else
+				src.prepend(?\u2B23.freeze)
+				src_meth.prepend(?\u2B23.freeze)
+			end
+		end
+
+
 		if MARKDOWN
-			puts "#{e}.#{meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{e}.#{disp_meth}\n=> #{dis}"
 		elsif HTML
-			puts "#{e}.#{meth}\n=> #{dis}"
+			puts "#{src}#{src_meth}#{e}.#{disp_meth}\n=> #{dis}"
 		else
-			puts "\e[1;38;2;80;80;255m#{e}.#{meth}\e[0m\n=> #{dis}"
+			puts "\e[1m#{src.colourize}\e[1m#{src_meth.colourize(4)}\e[0m\e[1;38;2;80;80;255m#{e}.#{disp_meth}\e[0m\n=> #{dis}"
 		end
 
 		puts( "(" +

data/ext/fs_stat/fs_stat.c

@@ -1,9 +1,13 @@
 #include <sys/statvfs.h>
 #include "ruby.h"
 
-#pragma GCC optimize ("O3")
-#pragma clang optimize on
-#pragma once
+#ifdef __GNUC__
+	#pragma GCC optimize ("O3")
+	#pragma GCC diagnostic warning "-Wall"
+#elif __clang__
+	#pragma clang optimize on
+	#pragma clang diagnostic warning "-Wall"
+#endif
 
 static VALUE statfs(VALUE obj, VALUE dir) {
 	struct statvfs buf ;

data/ext/sysconf/sysconf.c

@@ -1,9 +1,13 @@
 #include <unistd.h>
 #include "ruby.h"
 
-#pragma GCC optimize ("O3")
-#pragma clang optimize on
-#pragma once
+#ifdef __GNUC__
+	#pragma GCC optimize ("O3")
+	#pragma GCC diagnostic warning "-Wall"
+#elif __clang__
+	#pragma clang optimize on
+	#pragma clang diagnostic warning "-Wall"
+#endif
 
 static VALUE getTick(VALUE obj) {
 	return INT2FIX(sysconf(_SC_CLK_TCK)) ;
@@ -41,6 +45,22 @@ static VALUE getPosixVersion(VALUE obj) {
 	return INT2FIX(sysconf(_SC_VERSION)) ;
 }
 
+static VALUE getLineMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_LINE_MAX)) ;
+}
+
+static VALUE getExprNestMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_EXPR_NEST_MAX)) ;
+}
+
+VALUE getProcessorConfigured(VALUE obj) {
+	return INT2FIX(sysconf(_SC_NPROCESSORS_CONF)) ;
+}
+
+VALUE getProcessorOnline(VALUE obj) {
+	return INT2FIX(sysconf(_SC_NPROCESSORS_ONLN)) ;
+}
+
 static VALUE getUser(VALUE obj) {
 	char *name = getlogin() ;
 	return name ? rb_str_new_cstr(name) : rb_str_new_cstr("") ;
@@ -71,6 +91,11 @@ void Init_sysconf() {
 	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) ;
+	rb_define_module_function(_sysconf, "line_max", getLineMax, 0) ;
+	rb_define_module_function(_sysconf, "expr_nest_max", getExprNestMax, 0) ;
+
+	rb_define_module_function(_sysconf, "processor_online", getProcessorOnline, 0) ;
+	rb_define_module_function(_sysconf, "processor_configured", getProcessorConfigured, 0) ;
 
 	rb_define_module_function(_sysconf, "get_uid", getUID, 0) ;
 	rb_define_module_function(_sysconf, "get_gid", getGID, 0) ;

data/ext/utsname/utsname.c

@@ -1,40 +1,49 @@
 #include <sys/utsname.h>
 #include "ruby.h"
 
-#pragma GCC optimize ("O3")
-#pragma clang optimize on
-#pragma once
+#ifdef __GNUC__
+	#pragma GCC optimize ("O3")
+	#pragma GCC diagnostic warning "-Wall"
+#elif __clang__
+	#pragma clang optimize on
+	#pragma clang diagnostic warning "-Wall"
+#endif
 
 static struct utsname buf ;
-static short status ;
+
+static char *sysname = "", *nodename = "" ;
+static char *release = "", *version = "", *machine = "" ;
 
 void init_buf() {
-	status = uname(&buf) ;
+	short status = uname(&buf) ;
+
+	if (status > -1) {
+		sysname = buf.sysname ;
+		nodename = buf.nodename ;
+		release = buf.release ;
+		version = buf.version ;
+		machine = buf.machine ;
+	}
 }
 
 static VALUE getSysname(VALUE obj) {
-	VALUE sysname = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.sysname) ;
-	return sysname ;
+	return rb_str_new_cstr(sysname) ;
 }
 
 static VALUE getNodename(VALUE obj) {
-	VALUE nodename = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.nodename) ;
-	return nodename ;
+	return rb_str_new_cstr(nodename) ;
 }
 
 static VALUE getRelease(VALUE obj) {
-	VALUE release = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.release) ;
-	return release ;
+	return rb_str_new_cstr(release) ;
 }
 
 static VALUE getVersion(VALUE obj) {
-	VALUE version = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.version) ;
-	return version ;
+	return rb_str_new_cstr(version) ;
 }
 
 static VALUE getMachine(VALUE obj) {
-	VALUE machine = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.machine) ;
-	return machine ;
+	return rb_str_new_cstr(machine) ;
 }
 
 void Init_utsname() {

data/lib/linux_stat/cpu.rb

@@ -2,7 +2,7 @@ module LinuxStat
 	module CPU
 		class << self
 			##
-			# = stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# Where sleep is the delay to gather the data.
 			#
@@ -18,14 +18,14 @@ module LinuxStat
 			#    {0=>84.38, 1=>100.0, 2=>50.0, 3=>87.5, 4=>87.5}
 			#
 			# If the information is not available, it will return an empty Hash
-			def stat(sleep = ticks_to_ms)
+			def stat(sleep = ticks_to_ms_t5)
 				return {} unless stat?
 
 				data = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
 				sleep(sleep)
 				data2 = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
 
-				# On devices like android, the core count can change anytime.
+				# 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.
@@ -60,7 +60,7 @@ module LinuxStat
 			# It's like running LinuxStat::CPU.stat[0] but it's much more efficient and calculates just the aggregated usage which is available at the top of the /proc/stat file.
 			#
 			# If the information is not available, it will return nil.
-			def total_usage(sleep = ticks_to_ms)
+			def total_usage(sleep = ticks_to_ms_t5)
 				return nil unless stat?
 
 				data = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
@@ -76,12 +76,27 @@ module LinuxStat
 			end
 
 			##
-			# Returns the total number of CPU threads.
+			# Returns the total number of CPU threads online now.
+			#
+			# This value can change while a CPU is offline, due to kernel's hotplugging feature.
+			#
+			# If the information isn't available, it will return 0.
+			def online
+				# Let's rely on sysconf(_SC_NPROCESSORS_CONF), which is 100x faster than
+				# counting online cpu from /sys/devices/system/cpu
+
+				LinuxStat::Sysconf.processor_configured
+			end
+
+			##
+			# Returns the total number of CPU threads configured for the sysetm.
 			#
 			# If the information isn't available, it will return 0.
 			def count
-				# CPU count can change during the program runtime
-				cpuinfo.count { |x| x.start_with?('processor') }
+				# Let's rely on sysconf(_SC_NPROCESSORS_ONLN), which is 100x faster than running:
+				# IO.read('/sys/devices/system/cpu/online')[-2].to_i + 1
+
+				LinuxStat::Sysconf.processor_online
 			end
 
 			##
@@ -136,8 +151,11 @@ module LinuxStat
 				@@stat_readable ||= File.readable?('/proc/stat')
 			end
 
-			def ticks_to_ms
-				@@ms ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# Just to avoid duplicate calculations
+			# ticks to ms times 5
+			# If the ticks is 100, it will return 0.05
+			def ticks_to_ms_t5
+				@@ms_t5 ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
 			end
 		end
 	end

data/lib/linux_stat/os.rb

@@ -135,8 +135,8 @@ module LinuxStat
 					key = splitted[0].to_s.strip
 					value = splitted[1..-1].join(?=).to_s.strip
 
-					value[0] = '' if value[0] == ?"
-					value[-1] = '' if value[-1] == ?"
+					value[0] = ''.freeze if value[0] == ?".freeze
+					value[-1] = ''.freeze if value[-1] == ?".freeze
 
 					h.merge!( key.to_sym => value )
 				}

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_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,7 +244,7 @@ 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)
 
@@ -277,15 +277,15 @@ module LinuxStat
 			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:
 			#
@@ -298,7 +298,7 @@ module LinuxStat
 			# 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"
 				return nil unless File.readable?(file)
 
@@ -324,6 +324,54 @@ module LinuxStat
 				totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
 			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"
+				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
+			end
+
 			##
 			# = threads(pid = $$)
 			#
@@ -345,7 +393,7 @@ module LinuxStat
 				file = "/proc/#{pid}/stat".freeze
 				return nil unless File.readable?(file)
 
-				data = IO.read(file).split[19]
+				data = IO.foreach(file, ' '.freeze).first(20)[-1]
 				data ? data.to_i : nil
 			end
 
@@ -383,7 +431,7 @@ module LinuxStat
 				file = "/proc/#{pid}/status".freeze
 				return nil unless File.readable?(file)
 
-				data = IO.readlines(file.freeze).find { |x|
+				data = IO.foreach(file.freeze).find { |x|
 					x[/Uid.*\d*/]
 				}.to_s.split.drop(1)
 
@@ -402,12 +450,12 @@ module LinuxStat
 			#
 			#    :real, :effective, :saved_set, :filesystem_uid
 			#
-			# If the info isn't available it returns an empty Hash.
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return an empty Hash.
 			def gid(pid = $$)
 				file = "/proc/#{pid}/status".freeze
 				return nil unless File.readable?(file)
 
-				data = IO.readlines(file.freeze).find { |x|
+				data = IO.foreach(file.freeze).find { |x|
 					x[/Gid.*\d*/]
 				}.split.drop(1)
 
@@ -428,21 +476,132 @@ module LinuxStat
 				file = "/proc/#{pid}/status".freeze
 				return ''.freeze unless File.readable?(file)
 
-				gid = IO.readlines(file.freeze).find { |x|
+				gid = IO.foreach(file.freeze).find { |x|
 					x[/Gid.*\d*/]
 				}.split.drop(1)[2].to_i
 
 				LinuxStat::User.username_by_gid(gid)
 			end
 
+			##
+			# = start_time_epoch(pid = $$)
+			#
+			# Returns the epoch time (as Integer) the process was started.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.start_time_epoch 526
+			#
+			#    => 1608097744
+			#
+			# 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)
+
+				u = IO.foreach(uptime, ' '.freeze).next.to_f
+				st = (IO.foreach(stat_file, ' '.freeze).first(22)[-1].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
+			end
+
+			##
+			# = start_time(pid = $$)
+			#
+			# Returns the time (as Time object) the process was started.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.start_time 14183
+			#
+			#    => 2020-12-16 13:31:43 +0000
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
+			#
+			# The timezone returned based on current TZ.
+			# Thus the timezone could be affected by changing the ENV['TZ'] variable.
+			#
+			# Don't trust the timezone returned by the time.
+			def start_time(pid = $$)
+				# Getting two Time objects and dealing with floating point numbers
+				# Just to make sure the time goes monotonically
+				Time.at(start_time_epoch(pid))
+			end
+
+			##
+			# = running_time(pid = $$)
+			#
+			# Returns the time (in seconds, as Float) the process is running for.
+			#
+			# For example:
+			#    LinuxStat::ProcessInfo.running_time 14183
+			#
+			#    => 1947.619999999999
+			#
+			# 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)
+
+				IO.foreach(uptime, ' '.freeze).next.to_f - (IO.read(stat_file).split[21].to_i / get_ticks)
+			end
+
+			##
+			# = state(pid = $$)
+			# Returns the state of the process as a frozen String
+			#
+			# * A process could have multiple states:
+			#
+			# 1. S => Sleeping
+			#
+			# 2. R => Running
+			#
+			# 3. I => Idle
+			#
+			# 4. Z => Zombie
+			#
+			# It returns any one of them.
+			#
+			# 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)
+				IO.foreach(file, ' '.freeze).first(3)[-1].tap(&:rstrip!).freeze
+			end
+
+			##
+			# = nice(pid = $$)
+			# Returns the nice of the process
+			#
+			# The output value is an Integer ranging from -20 to 19
+			#
+			# -20 means the process has high priority, and 19 means the process has low priority
+			#
+			# 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)
+
+				IO.foreach(file, ' ').first(19)[-1].to_i
+			end
+
 			private
 			def get_ticks
 				@@ticks ||= Sysconf.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