miner_mover 0.0.0.4 → 0.1.1.1

data/demo/serial.rb

@@ -2,39 +2,32 @@ require 'miner_mover/run'
 
 include MinerMover
 
-run = Run.new.cfg_banner!(duration: 1)
-run.timer.timestamp!
-run.log "Starting"
+run = Run.new.cfg_banner!(duration: 1).start!
+run.timestamp!
+run.log "Starting #{__FILE__}"
 
 stop_mining = false
 Signal.trap("INT") {
-  run.timer.timestamp!
+  run.timestamp!
   run.log " *** SIGINT ***  Stop Mining"
   stop_mining = true
 }
 
-# system 'cpulimit', "--pid=#{Process.pid}", '--limit=1', '--background'
-
 miner = run.new_miner
 run.log "MINE Mining operation initialized  [ctrl-c] to stop"
 
 mover = run.new_mover
 run.log "MOVE Moving operation initialized"
-
 ore_mined = 0
 
-# miner waits for the SIGINT signal to quit
-while !stop_mining
-  # mine the ore
+while !stop_mining # SIGINT will trigger stop_mining = true
   ore = miner.mine_ore
   ore_mined += ore
-
-  # load (and possibly move) the ore
-  mover.load_ore ore if ore > 0
+  mover.load_ore ore if ore > 0 # move_batch happens when a batch is full
 
   # stop mining after a while
   if run.time_limit? or run.ore_limit?(ore_mined)
-    run.timer.timestamp!
+    run.timestamp!
     miner.log format("Mining limit reached: %s", Ore.display(ore_mined))
     stop_mining = true
   end
@@ -47,4 +40,4 @@ run.log "QUIT #{mover.status}"
 ore_moved = mover.ore_moved
 run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
 run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
-run.timer.timestamp!
+run.timestamp!

data/demo/thread.rb

@@ -3,13 +3,13 @@ require 'thread'
 
 include MinerMover
 
-run = Run.new.cfg_banner!(duration: 1)
-run.timer.timestamp!
-run.log "Starting"
+run = Run.new.cfg_banner!(duration: 1).start!
+run.timestamp!
+run.log "Starting #{__FILE__}"
 
 stop_mining = false
 Signal.trap("INT") {
-  run.timer.timestamp!
+  run.timestamp!
   run.log " *** SIGINT ***  Stop Mining"
   stop_mining = true
 }
@@ -24,16 +24,11 @@ movers = Array.new(run.num_movers) { |i|
     m = run.new_mover
     run.log "MOVE Mover #{i} started"
 
+    # movers pull from the queue, load the ore, and move it
     loop {
-      # a mover picks up mined ore from the queue
-      run.debug && m.log("POP ")
       ore = queue.pop
-      run.debug && m.log("POPD #{ore}")
-
       break if ore == :quit
-
-      # load (and possibly move) the ore
-      m.load_ore ore
+      m.load_ore ore # moving of ore possibly happens here (on a full batch)
     }
 
     # move any remaining ore and quit
@@ -45,6 +40,7 @@ movers = Array.new(run.num_movers) { |i|
 
 
 run.log "MINE Mining operation started  [ctrl-c] to stop"
+
 # store the miner threads in an array
 miners = Array.new(run.num_miners) { |i|
   Thread.new {
@@ -55,19 +51,12 @@ miners = Array.new(run.num_miners) { |i|
     # miners wait for the SIGINT signal to quit
     while !stop_mining
       ore = m.mine_ore
-
-      # send any ore mined to the movers
-      if ore > 0
-        run.debug && m.log("PUSH #{ore}")
-        queue.push ore
-        run.debug && m.log("PSHD #{ore}")
-      end
-
       ore_mined += ore
+      queue.push ore if ore > 0 # send any ore mined to the movers
 
       # stop mining after a while
       if run.time_limit? or run.ore_limit?(ore_mined)
-        run.timer.timestamp!
+        run.timestamp!
         m.log format("Mining limit reached: %s", Ore.display(ore_mined))
         stop_mining = true
       end
@@ -86,6 +75,7 @@ run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
 # tell all the movers to quit; gather their results
 run.num_movers.times { queue.push :quit }
 
+# wait for results
 ore_moved = movers.map { |thr| thr.value.ore_moved }.sum
 run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
-run.timer.timestamp!
+run.timestamp!

data/lib/miner_mover/config.rb

@@ -14,19 +14,22 @@ module MinerMover
         time_limit: 5,
         ore_limit: 100,
         logging: true,
+        debugging: false,
       }.freeze,
       miner: {
         depth: 30,
         partial_reward: false,
         variance: 0,
         logging: true,
+        debugging: false,
       }.freeze,
       mover: {
-        batch_size: 10,
-        rate: 2,
+        batch_size: 8,
+        rate: 4,
         work_type: :wait,
         variance: 0,
         logging: true,
+        debugging: false,
       }.freeze,
     }.freeze
 
@@ -60,7 +63,7 @@ module MinerMover
         mover = cfg[:mover] || {}
         main  = cfg[:main]  || {}
       else
-        raise(Error, "couldn't find miner, mover, or main in #{file}")
+        miner, mover, main = {}, {}, {}
       end
       { miner: DEFAULT[:miner].merge(miner),
         mover: DEFAULT[:mover].merge(mover),

data/lib/miner_mover/run.rb

@@ -1,5 +1,6 @@
 require 'miner_mover/worker'
 require 'miner_mover/config'
+require 'miner_mover/timer'
 
 module MinerMover
   class Run
@@ -15,35 +16,47 @@ module MinerMover
       f
     end
 
-    attr_accessor :debug, :logging
+    attr_accessor :debugging, :logging
     attr_accessor :num_miners, :num_movers
     attr_accessor :cfg_file, :cfg, :miner, :mover, :timer
     attr_accessor :time_limit, :ore_limit
 
-    def initialize(cfg_file: nil, timer: nil, debug: false)
+    def initialize(cfg_file: nil, timer: nil)
       @cfg_file = self.class.cfg_file(cfg_file)
       @cfg = Config.process @cfg_file
       main  = @cfg.fetch :main
       @miner = @cfg.fetch :miner
       @mover = @cfg.fetch :mover
 
+      @num_miners = main.fetch :num_miners
+      @num_movers = main.fetch :num_movers
+
       @time_limit = main.fetch :time_limit
       @ore_limit  = main.fetch :ore_limit
       @logging    = main.fetch :logging
-      @num_miners = main.fetch :num_miners
-      @num_movers = main.fetch :num_movers
+      @debugging  = main.fetch :debugging
 
-      @timer = timer || CompSci::Timer.new
-      @debug = debug
+      @timer = timer || Timer.new
     end
 
     def cfg_banner!(duration: 0)
-      log "USING: #{@cfg_file}"
+      MinerMover.puts "USING: #{@cfg_file}"
       pp @cfg
       sleep duration if duration > 0
       self
     end
 
+    def start!
+      @timer.restart
+      self
+    end
+
+    def timestamp!
+      dash = '-' * 70
+      str = [dash, Timer.timestamp, dash].join(MinerMover::LINE_SEP)
+      MinerMover.puts str
+    end
+
     def new_miner
       Miner.new(**@miner)
     end
@@ -61,7 +74,11 @@ module MinerMover
     end
 
     def log msg
-      @logging and puts(MinerMover.log_fmt(@timer, ' (main) ', msg))
+      @logging and MinerMover.log @timer, ' (main) ', msg
+    end
+
+    def debug msg
+      @debugging and MinerMover.log @timer, '(debug) ', msg
     end
   end
 end

data/lib/miner_mover/timer.rb

@@ -0,0 +1,67 @@
+module MinerMover
+  class Timer
+    SECS_PER_MIN = 60
+    MINS_PER_HOUR = 60
+    SECS_PER_HOUR = SECS_PER_MIN * MINS_PER_HOUR
+
+    # returns a float representing seconds since epoch
+    if defined? Process::CLOCK_MONOTONIC
+      def self.now
+        Process.clock_gettime Process::CLOCK_MONOTONIC
+      end
+    else
+      def self.now
+        Time.now.to_f
+      end
+    end
+
+    def self.since f
+      self.now - f
+    end
+
+    def self.elapsed &work
+      f = self.now
+      return yield, self.since(f)
+    end
+
+    # HH::MM::SS.mmm.uuuuuuuu
+    def self.elapsed_display(elapsed_ms, show_micro: false)
+      elapsed_s, ms = elapsed_ms.divmod 1000
+      ms_only, ms_fraction = ms.round(8).divmod 1
+
+      h = elapsed_s / SECS_PER_HOUR
+      elapsed_s -= h * SECS_PER_HOUR
+      m, s = elapsed_s.divmod SECS_PER_MIN
+
+      hmsms = [[h, m, s].map { |i| i.to_s.rjust(2, '0') }.join(':'),
+               ms_only.to_s.rjust(3, '0')]
+      hmsms << (ms_fraction * 10 ** 8).round.to_s.ljust(8, '0') if show_micro
+      hmsms.join('.')
+    end
+
+    # YYYY-MM-DD HH::MM::SS.mmm
+    def self.timestamp(t = Time.now)
+      t.strftime "%Y-%m-%d %H:%M:%S.%L"
+    end
+
+    def restart(f = Timer.now)
+      @start = f
+      self
+    end
+    alias_method :initialize, :restart
+
+    def elapsed(f = Timer.now)
+      f - @start
+    end
+
+    def elapsed_ms(f = Timer.now)
+      elapsed(f) * 1000
+    end
+
+    def elapsed_display(f = Timer.now)
+      Timer.elapsed_display(elapsed_ms(f))
+    end
+    alias_method :to_s, :elapsed_display
+    alias_method :inspect, :elapsed_display
+  end
+end

data/lib/miner_mover/worker.rb

@@ -1,16 +1,15 @@
 require 'miner_mover'
-require 'compsci/timer'
-require 'compsci/fibonacci'
+require 'miner_mover/timer'
 
 module MinerMover
-  def self.work(duration, type = :wait, fib = 30)
+  def self.work(duration, type = :wait, fib_target = 30)
     case type
     when :wait
       sleep duration
       duration
     when :cpu
-      t = CompSci::Timer.new
-      CompSci::Fibonacci.classic(fib) while t.elapsed < duration
+      t = Timer.new
+      self.fib(fib_target) while t.elapsed < duration
       t.elapsed
     when :instant
       0
@@ -19,14 +18,19 @@ module MinerMover
     end
   end
 
+  def self.fib n
+    (n < 2) ?  n  :  fib(n-1) + fib(n-2)
+  end
+
   class Worker
-    attr_accessor :variance, :logging
+    attr_accessor :variance, :logging, :debugging
     attr_reader :timer
 
-    def initialize(variance: 0, logging: false, timer: nil)
+    def initialize(variance: 0, logging: false, debugging: false, timer: nil)
       @variance = variance
       @logging = logging
-      @timer = timer || CompSci::Timer.new
+      @debugging = debugging
+      @timer = timer || Timer.new
     end
 
     def id
@@ -36,6 +40,7 @@ module MinerMover
     def state
       { id: self.id,
         logging: @logging,
+        debugging: @debugging,
         timer: @timer.elapsed_ms.round,
         variance: @variance }
     end
@@ -45,7 +50,11 @@ module MinerMover
     end
 
     def log msg
-      @logging && puts(MinerMover.log_fmt(@timer, self.id, msg))
+      @logging and MinerMover.log @timer, self.id, msg
+    end
+
+    def debug msg
+      @debugging and MinerMover.log @timer, self.id, msg
     end
 
     # 4 levels:
@@ -68,30 +77,36 @@ module MinerMover
   class Miner < Worker
     attr_accessor :depth, :partial_reward
 
-    def initialize(depth: 10,
-                   partial_reward: true,
+    def initialize(depth: 5,
+                   partial_reward: false,
                    variance: 0,
                    logging: false,
+                   debugging: false,
                    timer: nil)
       @partial_reward = partial_reward
       @depth = depth
-      super(variance: variance, logging: logging, timer: timer)
+      super(variance: variance, timer: timer,
+            logging: logging, debugging: debugging)
     end
 
     def state
       super.merge(depth: @depth, partial_reward: @partial_reward)
     end
 
+    # return an array of integers representing ore mined at each depth
+    def mine_ores(depth = @depth)
+      # every new depth is a new mining operation
+      Array.new(depth) { |d|
+        # mine ore by calculating fibonacci for that depth
+        mined = MinerMover.fib(self.varied(d).round)
+        @partial_reward ? rand(1 + mined) : mined
+      }
+    end
+
+    # wrap the above method with logging, timing, and summing
     def mine_ore(depth = @depth)
       log format("MINE Depth %i", depth)
-      ores, elapsed = CompSci::Timer.elapsed {
-        # every new depth is a new mining operation
-        Array.new(depth) { |d|
-          # mine ore by calculating fibonacci for that depth
-          mined = CompSci::Fibonacci.classic(self.varied(d).round)
-          @partial_reward ? rand(1 + mined) : mined
-        }
-      }
+      ores, elapsed = Timer.elapsed { self.mine_ores(depth) }
       total = ores.sum
       log format("MIND %s %s (%.2f s)",
                  Ore.display(total), ores.inspect, elapsed)
@@ -107,12 +122,14 @@ module MinerMover
                    work_type: :cpu,
                    variance: 0,
                    logging: false,
+                   debugging: false,
                    timer: nil)
       @batch_size = batch_size * Ore::BLOCK
       @rate = rate.to_f * Ore::BLOCK
       @work_type = work_type
       @batch, @batches, @ore_moved = 0, 0, 0
-      super(variance: variance, logging: logging, timer: timer)
+      super(variance: variance, timer: timer,
+            logging: logging, debugging: debugging)
     end
 
     def state
@@ -132,33 +149,37 @@ module MinerMover
       ].join(' | ')
     end
 
-    def load_ore(amt)
-      @batch += amt
+    # accept some ore for moving; just accumulate unless we have a full batch
+    def load_ore amount
+      log format("LOAD %s | %s", Ore.display(amount), self.status)
+      @batch += amount
       move_batch if @batch >= @batch_size
-      log format("LOAD %s", self.status)
+      log format("LDED %s | %s", Ore.display(amount), self.status)
       @batch
     end
 
-    def move(duration)
-      MinerMover.work(duration, @work_type)
-    end
-
+    # return the amount moved
     def move_batch
       raise "unexpected batch: #{@batch}" if @batch <= 0
-      amt = [@batch, @batch_size].min
-      duration = self.varied(amt / @rate)
+      amount = [@batch, @batch_size].min
 
-      log format("MOVE %s (%.2f s)", Ore.display(amt), duration)
-      _, elapsed = CompSci::Timer.elapsed { self.move(duration) }
-      log format("MOVD %s (%.2f s)", Ore.display(amt), elapsed)
+      self.move amount
 
       # accounting
-      @ore_moved += amt
-      @batch -= amt
+      @ore_moved += amount
+      @batch -= amount
       @batches += 1
 
-      # what moved
-      amt
+      amount
+    end
+
+    # perform the work of moving the amount of ore
+    def move amount
+      duration = self.varied(amount / @rate)
+      log format("MOVE %s (%.2f s)", Ore.display(amount), duration)
+      _, elapsed = Timer.elapsed { MinerMover.work(duration, @work_type) }
+      log format("MOVD %s (%.2f s)", Ore.display(amount), elapsed)
+      self
     end
   end
 end

data/lib/miner_mover.rb

@@ -1,7 +1,30 @@
 module MinerMover
-  # called by Worker instances, available for general use
+  LINE_SEP = $/.freeze
+
+  # $/ is the default line separator: "\n"
+  def self.puts(str, io = $stdout, separator = LINE_SEP)
+    self.write_nonblock(io, str + separator)
+  end
+
+  def self.write_nonblock(io, str)
+    begin
+      # nonblocking write attempt; ensure the full string is written
+      size = str.bytesize
+      num_bytes = io.write_nonblock(str)
+      # blocking write if nonblocking write comes up short
+      io.write str.byteslice(num_bytes, size - num_bytes) if num_bytes < size
+    rescue IO::WaitWritable, Errno::EINTR
+      IO.select([], [io]) # wait until writable
+      retry
+    end
+  end
+
   def self.log_fmt(timer, id, msg)
-    format("%s %s %s", timer.elapsed_display, id, msg)
+    format("%s %s %s", timer, id, msg)
+  end
+
+  def self.log(timer, id, msg)
+    self.puts self.log_fmt(timer, id, msg)
   end
 
   # i +- 50% at squeeze 0
@@ -18,7 +41,28 @@ module MinerMover
 
   # ore is handled in blocks of 1M
   module Ore
-    BLOCK = 1_000_000
+    BLOCK = 1_000_000  # between fib(30) and fib(31)
+    WORD_LENGTH = 4    # bytes
+    WORD_MAX = 256 ** WORD_LENGTH      # up to 4.3B ore
+    HEX_UNPACK = "H#{WORD_LENGTH * 2}" # 4 bytes is 8 hex digits
+
+    # return 4 bytes, unsigned 32 bit integer, network order
+    def self.encode(ore)
+      raise "WORD_MAX overflow: #{self.block(ore)}M ore" if ore > WORD_MAX
+      [ore].pack('N')
+    end
+
+    # return an integer from the first 4 bytes
+    def self.decode(word)
+      raise "unexpected size: #{word.bytesize}" unless word.bytesize == 4
+      word.unpack('N').first
+    end
+
+    # return "0x01020304" for "\x01\x02\x03\x04"
+    def self.hex(word)
+      raise "unexpected size: #{word.bytesize}" unless word.bytesize == 4
+      "0x" + word.unpack(HEX_UNPACK).first
+    end
 
     # raw ore in, blocks out
     def self.block(ore, size = BLOCK)

data/miner_mover.gemspec

@@ -18,13 +18,16 @@ EOF
   s.files += Dir['test/**/*.rb']
   s.files += Dir['demo/**/*.rb']
 
-  s.add_dependency "compsci", "~> 0.3"
   s.add_dependency "dotcfg", "~> 1.0"
-  s.add_dependency "fiber_scheduler", "~> 0.13"
 
-  s.add_development_dependency "buildar", "~> 3.0"
-  s.add_development_dependency "minitest", "~> 5.0"
+  s.requirements << "For all features and best performance:"
+  s.requirements << "gem install rake minitest fiber_scheduler"
+  s.requirements << "For dev tools:"
+  s.requirements << "gem install buildar flog flay"
+
   s.add_development_dependency "rake", "~> 13.0" # CVE-2020-8130
+  s.add_development_dependency "minitest", "~> 5.0"
+  s.add_development_dependency "buildar", "~> 3.0"
   s.add_development_dependency "flog", "~> 0"
   s.add_development_dependency "flay", "~> 0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: miner_mover
 version: !ruby/object:Gem::Version
-  version: 0.0.0.4
+  version: 0.1.1.1
 platform: ruby
 authors:
 - Rick Hull
@@ -10,20 +10,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: compsci
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: dotcfg
   requirement: !ruby/object:Gem::Requirement
@@ -39,33 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: fiber_scheduler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.13'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.13'
-- !ruby/object:Gem::Dependency
-  name: buildar
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -81,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: buildar
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: flog
   requirement: !ruby/object:Gem::Requirement
@@ -139,13 +111,15 @@ files:
 - demo/config.rb
 - demo/fiber.rb
 - demo/fiber_scheduler.rb
-- demo/process.rb
+- demo/process_pipe.rb
+- demo/process_socket.rb
 - demo/ractor.rb
 - demo/serial.rb
 - demo/thread.rb
 - lib/miner_mover.rb
 - lib/miner_mover/config.rb
 - lib/miner_mover/run.rb
+- lib/miner_mover/timer.rb
 - lib/miner_mover/worker.rb
 - miner_mover.gemspec
 - test/miner_mover.rb
@@ -167,7 +141,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- 'For all features and best performance:'
+- gem install rake minitest fiber_scheduler
+- 'For dev tools:'
+- gem install buildar flog flay
 rubygems_version: 3.3.20
 signing_key:
 specification_version: 4