miner_mover 0.1.0.1 → 0.1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d6d5e0e85b066dc78e4e6c7b86d751245f1e2b3809ab176f9b69e7047c2d330
-  data.tar.gz: cd0f57ea360871fefdb7927eddef3651a277c8e8116d41a2da085dcf02a3ed73
+  metadata.gz: 9e2daa3ba8e778e20c25e3a6363683b3163e1141f9438b53be890845acf5440e
+  data.tar.gz: b72dc662be9c50caa281e087b3708c72a53aa5e593eeb053b59a0679238d568b
 SHA512:
-  metadata.gz: 1a8d2759692483f004c0d512a17b2b4ec6a10e6d26b3e66b8785b28a0510cc3eaf7ad029b95f0a11a37b0264dc028e3c65a5cbccffbc64e5446365cdaf9ae2ce
-  data.tar.gz: d88946c92b88073fc01f4b57ae0f13ba157ca7a72c85ae6ad405a0569b311e5420689d76014c5cda88c709b2dfbfa2dbed6b090e2c001894fdf4267686cbd87d
+  metadata.gz: 3203db4674a641c4a53ebed0cea4aaa445ef9e120ad582bc1cfcc787541ee53a8677eff1e4936429c4eaa72ef686ef97941a7a929d2d5db4e88a678684005962
+  data.tar.gz: e0052a82fa40bcf19b3382ead683087e52f90e6065751a65ff9475aadd141beb0ebe098673acffe48784f90c672aa5990fe2c0e117a3db4bd1782252af7cec91

data/README.md

@@ -18,7 +18,7 @@ results as well.  Ore is gathered at each depth; either a fixed amount or
 randomized, based on depth.  The amount of time spent mining each level is
 independent and may be randomized.
 
-https://github.com/rickhull/miner_mover/blob/bd76ea400944aab8eab9e3ffcac85d1e28353eff/lib/miner_mover/worker.rb#L85-L99
+https://github.com/rickhull/miner_mover/blob/4f2a62f6d77316e780c7c13248698d4c57bb392e/lib/miner_mover/worker.rb#L96-L104
 
 In this case, miners are rewarded by calculating `fibonacci(depth)`, using
 classic, inefficient fibonacci.
@@ -31,7 +31,7 @@ A mover has a batch size, say 10.  As the mover accumulates ore over time,
 once the batch size is reached, the mover delivers the ore to the destination.
 Larger batches take longer.  The delivery time can be randomized.
 
-https://github.com/rickhull/miner_mover/blob/bd76ea400944aab8eab9e3ffcac85d1e28353eff/lib/miner_mover/worker.rb#L135-L162
+https://github.com/rickhull/miner_mover/blob/4f2a62f6d77316e780c7c13248698d4c57bb392e/lib/miner_mover/worker.rb#L152-L183
 
 The time and work spent delivering ore can be simulated three ways,
 configured via `:work_type`
@@ -44,7 +44,7 @@ configured via `:work_type`
 
 ## Install
 
-You'll want to use **Ruby 3.x** to make the most of Fibers.
+You'll want to use **Ruby 3.x** (CRuby) to make the most of Fibers.
 
 ### Dependencies
 
@@ -53,8 +53,6 @@ You'll want to use **Ruby 3.x** to make the most of Fibers.
 * dotcfg
 * fiber_scheduler
 
-`gem install miner_mover` will take care of the following:
-
 `gem install rake minitest dotcfg fiber_scheduler`
 
 ### Clone
@@ -85,6 +83,8 @@ rake test             # Run tests
 rake thread           # run demo/thread
 ```
 
+Try: `rake test`
+
 ## Rake Tasks
 
 Included demonstration scripts can be executed via Rake tasks.
@@ -113,7 +113,7 @@ Rake tasks take care of `LOAD_PATH`, so the following is
 
 ## Exploration in `irb`
 
-`$ irb -Ilib -rminer_mover/worker`
+`$ irb -I lib`
 
 ```
 irb(main):001:0> include MinerMover
@@ -379,11 +379,15 @@ others.  My favorites:
 
 * `Process.fork` - when called with a block, the block is only executed in the
   child subprocess
-* `Process.spawn` - extensive options, nonblocking, call Process.wait(pid)
+* `Process.spawn` - extensive options, nonblocking, call `Process.wait(pid)`
   to get the result
-* `Open3.popen3` - for access to STDIN, STDOUT, STDERR
+* `Open3.popen3` - for access to `STDIN` `STDOUT` `STDERR`
 
 ### IPC
 
-* Pipes - streaming bytes: `IO.pipe`
-* Unix sockets - messages with datagrams: `Socket.pair(:UNIX, :DGRAM, 0)`
+* Pipes
+  - `IO.pipe` (streaming / bytes / unidirectional)
+* Unix sockets
+  - `UNIXSocket.pair :RAW`
+  - `UNIXSocket.pair :DGRAM`  (datagram / message / "like UDP")
+  - `UNIXSocket.pair :STREAM` (streaming / bytes / "like TCP")

data/VERSION

@@ -1 +1 @@
-0.1.0.1
+0.1.1.1

data/lib/miner_mover/timer.rb

@@ -44,22 +44,22 @@ module MinerMover
       t.strftime "%Y-%m-%d %H:%M:%S.%L"
     end
 
-    def restart(t = Time.now)
-      @start = t
+    def restart(f = Timer.now)
+      @start = f
       self
     end
     alias_method :initialize, :restart
 
-    def elapsed(t = Time.now)
-      t - @start
+    def elapsed(f = Timer.now)
+      f - @start
     end
 
-    def elapsed_ms(t = Time.now)
-      elapsed(t) * 1000
+    def elapsed_ms(f = Timer.now)
+      elapsed(f) * 1000
     end
 
-    def elapsed_display(t = Time.now)
-      Timer.elapsed_display(elapsed_ms(t))
+    def elapsed_display(f = Timer.now)
+      Timer.elapsed_display(elapsed_ms(f))
     end
     alias_method :to_s, :elapsed_display
     alias_method :inspect, :elapsed_display

data/lib/miner_mover/worker.rb

@@ -77,32 +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,
-            debugging: debugging, 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 = Timer.elapsed {
-        # 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
-        }
-      }
+      ores, elapsed = Timer.elapsed { self.mine_ores(depth) }
       total = ores.sum
       log format("MIND %s %s (%.2f s)",
                  Ore.display(total), ores.inspect, elapsed)
@@ -124,8 +128,8 @@ module MinerMover
       @rate = rate.to_f * Ore::BLOCK
       @work_type = work_type
       @batch, @batches, @ore_moved = 0, 0, 0
-      super(variance: variance, logging: logging,
-            debugging: debugging, timer: timer)
+      super(variance: variance, timer: timer,
+            logging: logging, debugging: debugging)
     end
 
     def state
@@ -145,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 = 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: miner_mover
 version: !ruby/object:Gem::Version
-  version: 0.1.0.1
+  version: 0.1.1.1
 platform: ruby
 authors:
 - Rick Hull