sunburst 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bac5cf8138ded782d5114cf84c9d05f3f06e748328024aaa2c99783187c734ac
-  data.tar.gz: a8959e5ff6b66c568b0c5d7ead18abdb5c1df9305155e4e9f29ca0c449074617
+  metadata.gz: 9ecfac43448912f08b86571fecabeb676b11902524428b542973b83f535eeb71
+  data.tar.gz: 85668f8a6cb4a40f48e9e6f24c43dae60cf07b68a9ab1b6d4f5559b2eb8f0d71
 SHA512:
-  metadata.gz: bad636441bee759ab7783226a3ea6e0e86b5cfae584b1ddc81f2d181df354101c58c43092f38f80136d00e22846641199b5256bc8c80da5f398e29d32a990432
-  data.tar.gz: 8846d22b978e865380622bd7139d0260c7d0f9a3b6c2e43c01230bedeb5f7f473b24136ac1a9dc1a08b85e7efa7f7029a33f439630cd24fa49e6876dd17626c5
+  metadata.gz: '09483bbbc6011547a6cbc1a691363545d5c7002dbfca9c593fde20bb4083df5995e449e02d319bd65054967b164417a2cc2662cca41541c647ab745f67e776fe'
+  data.tar.gz: 42c5ce9d7ba09046ddb22c27cb8de6ac64c64a488b0a52a3cb52357aa2d1fc3f4029e8772fa3543c6725ac5ada1258c4876564c0fb7ddd07ab2593d84d2e0463

data/exe/sunburst

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# Frozen_String_Literal: true
+
 $-v = nil
 STDOUT.sync = STDIN.sync = true
 require 'sunburst'
@@ -15,13 +17,16 @@ def help
 		Arguments:
 		\s\s\s\s--time=N\s\s\s\s\s\s\s\s\s\sRun the program for N seconds
 		\s\s\s\s-h | --help\s\s\s\s\s\s\sShow this help section
+		\s\s\s\s-p | --progress\s\s\sShow realtime stats of the process
 		\s\s\s\s--humanize\s\s\s\s\s\s\s\sHuman readable memory units
 
 		Example:
 		\s\s\s\ssunburst echo hello world --time=0.05 --humanize
 		\s\s\s\ssunburst "echo hello world" --time=0.05 --humanize
 		\s\s\s\ssunburst "ruby -e 'while true do end'" --time=3 --humanize
-		\s\s\s\ssunburst "ruby -e 'p :Hello'" --time=3 --humanize
+		\s\s\s\ssunburst "ruby -e 'p :Hello'" --time=3
+		\s\s\s\ssunburst "while : ; do : ; done" --time=3 --humanize --progress
+
 	EOF
 
 	exit 0
@@ -32,6 +37,20 @@ def splitter(sub = 8)
 	puts ?\n, ?-.*(width - sub).center(width)
 end
 
+def convert_bytes(mem)
+	if mem >= 10 ** 12
+		"#{"%06.3f" % mem.fdiv(10 ** 12)} TB"
+	elsif mem >= 10 ** 9
+		"#{"%06.3f" % mem.fdiv(10 ** 9)} GB"
+	elsif mem >= 10 ** 6
+		"#{"%06.3f" % mem.fdiv(10 ** 6)} MB"
+	elsif mem >= 10 ** 3
+		"#{"%06.3f" % mem.fdiv(10 ** 3)} KB"
+	else
+		"#{"%06.3f" % mem} Bytes"
+	end
+end
+
 help if ARGV.any? { |x| x[/^\-(\-help|h)$/] }
 
 time_arg = ARGV.find { |x| x[/^\-\-time=[0-9]+\.?[0-9]*$/] }
@@ -42,20 +61,49 @@ _human_readable = ARGV.find { |x| x[/^\-\-humanize$/] }
 ARGV.delete(_human_readable) if _human_readable
 human_readable = _human_readable
 
+_progress = ARGV.find { |x| x[/^\-(\-progress|p)$/] }
+ARGV.delete(_progress) if _progress
+progress = _progress
+
 command = ARGV.join(' ')
 
 help if command.empty?
 
 puts %Q(:: Running "#{command}" for #{time || 'infinite'} seconds)
 
-
 begin
-	print ""
+	message = if progress
+		"\e[4mLogging Stats, Ignoring Standard Output and Error\e[0m"
+	else
+		"\e[4mLogging Standard Output and Error\e[0m"
+	end
 
-	message = "\e[4mLogging Standard Output and Error\e[0m"
 	puts "\e[38;2;243;156;18m#{message.center(Sunburst.win_width + 6)}\e[0m"
 
-	data = Sunburst.measure(command: command, time: time, sleep_time: 0.0001)
+	data = if progress
+		if human_readable
+			Sunburst.measure(command: command, time: time, sleep_time: 0.0001) { |exec_t, cpu_t, mem, threads, state|
+				print "\e[2K:: "\
+				"Exec T: #{"%05.2f" % exec_t}s | "\
+				"CPU T: #{"%05.2f" % cpu_t}s | "\
+				"Mem: #{convert_bytes(mem)} | "\
+				"Threads: #{threads} | "\
+				"State: #{state}\r"
+			}
+		else
+			Sunburst.measure(command: command, time: time, sleep_time: 0.0001) { |exec_t, cpu_t, mem, threads, state|
+				print "\e[2K:: "\
+				"Exec T: #{"%05.2f" % exec_t} | "\
+				"CPU T: #{"%05.2f" % cpu_t} | "\
+				"Mem: #{"%2d" % mem} | "\
+				"Threads: #{threads} | "\
+				"State: #{state}\r"
+			}
+		end
+	else
+		Sunburst.measure(command: command, time: time, sleep_time: 0.0001)
+	end
+
 	print "\e[38;2;243;156;18m"
 	splitter()
 	print "\e[0m"
@@ -64,7 +112,7 @@ begin
 	cpu_time = data[:cpu_time]
 	percent_time = cpu_time.*(100).fdiv(exec_time)
 
-	style = "\e[1;"
+	style = +"\e[1;"
 	style << if percent_time > 75
 		"38;2;230;80;70m"
 	elsif percent_time > 50
@@ -76,13 +124,13 @@ begin
 	end
 
 	puts ":: Total Execution Time: #{data[:execution_time]} seconds\e[0m"
-	puts ":: CPU Time: #{style}#{data[:cpu_time]}\e[0m second#{?s if data[:cpu_time] != 1} (#{percent_time.round(3)}% exec time)"
+	puts ":: Total CPU Time: #{style}#{data[:cpu_time]}\e[0m second#{?s if data[:cpu_time] != 1} (#{percent_time.round(3)}% exec time)"
 
 	mem = data[:memory]
 	if mem
 		percent_mem = mem.*(100).fdiv(Sunburst.total_ram)
 
-		style = "\e[1;"
+		style = +"\e[1;"
 		style << if percent_mem > 50
 			"38;2;230;80;70m"
 		elsif percent_mem > 30
@@ -94,28 +142,44 @@ begin
 		end
 
 		if human_readable
-			mem_text = if mem >= 10 ** 12
-				"#{mem.fdiv(10 ** 12).round(3)} TB"
-			elsif mem >= 10 ** 9
-				"#{mem.fdiv(10 ** 9).round(3)} GB"
-			elsif mem >= 10 ** 6
-				"#{mem.fdiv(10 ** 6).round(3)} MB"
-			elsif mem >= 10 ** 3
-				"#{mem.fdiv(10 ** 3).round(3)} KB"
-			else
-				"#{mem} Bytes"
-			end
-
-			puts ":: Memory usage: #{style}#{mem_text}\e[0m (#{percent_mem.round(3)}% system mem)"
+			mem_text = convert_bytes(mem)
+
+			puts ":: Memory Usage During Exit: #{style}#{mem_text}\e[0m (#{percent_mem.round(3)}% system mem)"
+		else
+			puts ":: Memory Usage During Exit: #{style}#{mem} bytes\e[0m (#{percent_mem.round(3)}% system mem)"
+		end
+	else
+		puts ":: The memory Usage Can't be Logged."
+	end
+
+	max_mem = data[:max_memory]
+	if max_mem
+		percent_mem = max_mem.*(100).fdiv(Sunburst.total_ram)
+
+		style = +"\e[1;"
+		style << if percent_mem > 50
+			"38;2;230;80;70m"
+		elsif percent_mem > 30
+			"38;2;45;125;255m"
+		elsif percent_mem > 10
+			"38;2;255;225;0m"
+		else
+			"38;2;40;175;95m"
+		end
+
+		if human_readable
+			mem_text = convert_bytes(max_mem)
+
+			puts ":: Max Memory Usage: #{style}#{mem_text}\e[0m (#{percent_mem.round(3)}% system mem)"
 		else
-			puts ":: Memory usage: #{style}#{mem} bytes\e[0m (#{percent_mem.round(3)}% system mem)"
+			puts ":: Max Memory Usage: #{style}#{max_mem} bytes\e[0m (#{percent_mem.round(3)}% system mem)"
 		end
 	else
-		puts ":: The memory usage can't be logged."
+		puts ":: The max memory Usage can't be logged."
 	end
 
 	max_threads = data[:max_threads]
-	style = "\e[1;"
+	style = +"\e[1;"
 	style << if max_threads > 16
 		"38;2;230;80;70m"
 	elsif max_threads > 8

data/ext/stats/stats.c

@@ -40,27 +40,29 @@ VALUE ps_stat(volatile VALUE obj, volatile VALUE pid) {
 
 	// For this info
 	// follow https://man7.org/linux/man-pages/man5/proc.5.html
+	char state[1] ;
 	int ppid, processor ;
 	long unsigned utime, stime ;
 	long num_threads ;
 
 	char status = fscanf(
-		f, "%*llu (%*[^)]%*[)] %*c "
+		f, "%*llu (%*[^)]%*[)] %1s "
 		"%d %*d %*d %*d %*d %*u "
 		"%*lu %*lu %*lu %*lu %lu %lu "
 		"%*ld %*ld %*ld %*ld %ld",
-		&ppid, &utime, &stime, &num_threads
+		&state, &ppid, &utime, &stime, &num_threads
 	) ;
 
 	fclose(f) ;
 
-	if (status != 4) return rb_ary_new() ;
+	if (status != 5) return rb_ary_new() ;
 
-	return rb_ary_new_from_args(4,
+	return rb_ary_new_from_args(5,
 		INT2NUM(ppid),
 		ULONG2NUM(utime),
 		ULONG2NUM(stime),
-		LONG2NUM(num_threads)
+		LONG2NUM(num_threads),
+		rb_str_new(state, 1)
 	) ;
 }
 

data/lib/sunburst/sunburst.rb

@@ -11,30 +11,53 @@ module Sunburst
 	end
 
 	def self.measure(command:, time: nil, sleep_time: 0.001)
+		progress = block_given?
+
 		r = {
 			execution_time: nil, cpu_time: nil,
-			memory: nil, max_threads: nil
+			memory: nil, max_threads: nil,
+			max_memory: nil, state: nil, last_state: nil
 		}
 
 		IO.popen(command) { |x|
 			time1 = Sunburst.clock_monotonic
 			pid = x.pid
 
-			t = Thread.new { print x.readpartial(4096) until x.eof? }
+			t = if progress
+				Thread.new { }
+			else
+				Thread.new { print x.readpartial(4096) until x.eof? }
+			end
 
 			last_mem = 0
 			max_threads = 0
+			max_mem = 0
+			last_state = nil
 
 			while true
 				_last_mem = Sunburst.get_mem(pid)
 
 				break if (time && Sunburst.clock_monotonic - time1 > time) || _last_mem == 0
 				last_mem = _last_mem
+				max_mem = last_mem if max_mem < _last_mem
 
 				# Get stats
 				stats = get_stats(pid)
 				_threads = stats[3]
 				max_threads = _threads if max_threads < _threads
+				last_state = stats[4]
+
+				cpu_time = stats[1].+(stats[2]).fdiv(Sunburst::TICKS)
+
+				if progress
+					yield(
+						Sunburst.clock_monotonic.-(time1),
+						stats[1].+(stats[2]).fdiv(Sunburst::TICKS),
+						_last_mem * Sunburst::PAGESIZE,
+						_threads,
+						last_state
+					)
+				end
 
 				sleep(sleep_time)
 			end
@@ -48,18 +71,23 @@ module Sunburst
 			_threads = stats[3]
 			max_threads = _threads if max_threads < _threads
 
-			# Get Memory Usage
 			_last_mem = Sunburst.get_mem(pid)
+			max_mem = _last_mem if max_mem < _last_mem
 			last_mem = _last_mem unless _last_mem == 0
 
+			state = stats[4]
+
 			t.kill
 			Process.kill(9, pid)
 
 			r[:cpu_time] = cpu_time
 			r[:max_threads] = max_threads unless max_threads == 0
 			r[:memory] = last_mem * Sunburst::PAGESIZE if last_mem > 0
+			r[:max_memory] = max_mem * Sunburst::PAGESIZE if last_mem > 0
 
 			r[:execution_time] = time2.-(time1).truncate(5)
+			r[:state] = state
+			r[:last_state] = last_state
 		}
 
 		r

data/lib/sunburst/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sunburst
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sunburst
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sourav Goswami
@@ -18,11 +18,9 @@ executables:
 - sunburst
 extensions:
 - ext/stats/extconf.rb
-extra_rdoc_files:
-- README.md
+extra_rdoc_files: []
 files:
 - LICENCE
-- README.md
 - bin/setup
 - exe/sunburst
 - ext/stats/extconf.rb

data/README.md

@@ -1,78 +0,0 @@
-# Sunburst
-Sunburst lets you run a command for a given time.
-When the time expires, the program will be SIGKILLed.
-Sunburst will then report the total CPU time and last known memory usage
-of the program.
-
-For example:
-
-```
-$ sunburst "while : ; do echo hi ; sleep 1 ; done" --time=3
-:: Running "while : ; do echo hi ; sleep 1 ; done" for 3.0 seconds
-                     Logging Standard Output and Error
-hi
-hi
-hi
-
-    ----------------------------------------------------------------------
-:: Total Execution Time: 3.00097 seconds
-:: CPU Time: 0.0 seconds (0.0% exec time)
-:: Memory usage: 577536 bytes (0.007% system mem)
-:: Max Threads: 1
-```
-
-Or
-
-```
-$ sunburst "while : ; do : ; done" --time=3
-:: Running "while : ; do : ; done" for 3.0 seconds
-                     Logging Standard Output and Error
-
-    ----------------------------------------------------------------------
-:: Total Execution Time: 3.00097 seconds
-:: CPU Time: 2.97 seconds (98.968% exec time)
-:: Memory usage: 360448 bytes (0.004% system mem)
-:: Max Threads: 1
-```
-
-## Installation
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'sunburst'
-```
-
-And then execute:
-
-```
-$ bundle install
-```
-
-Or install it yourself as:
-```
-$ gem install sunburst
-```
-
-## Usage
-Run sunbust -h for instruction.
-
-```
-Arguments:
-    --time=N          Run the program for N seconds
-    -h | --help       Show this help section
-    --humanize        Human readable memory units
-
-Example:
-    sunburst echo hello world --time=0.05 --humanize
-    sunburst "echo hello world" --time=0.05 --humanize
-    sunburst "ruby -e 'while true do end'" --time=3 --humanize
-    sunburst "ruby -e 'p :Hello'" --time=3 --humanize
-```
-
-If no time is specified, it will run until the command exits.
-
-## Contributing
-Bug reports and pull requests are welcome on GitHub at https://github.com/Souravgoswami/sunburst.
-
-## License
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).