miner_mover 0.1.0.1 → 0.1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d6d5e0e85b066dc78e4e6c7b86d751245f1e2b3809ab176f9b69e7047c2d330
-  data.tar.gz: cd0f57ea360871fefdb7927eddef3651a277c8e8116d41a2da085dcf02a3ed73
+  metadata.gz: d6d1e4d4ee9ab3ff3dedcd283b94f1c089dd6478657f215d0903a18bcbaa576f
+  data.tar.gz: b0d0a6fc768ede45676fa68545379e915d98e9c9f8d6416c48b7bd564b8b09fc
 SHA512:
-  metadata.gz: 1a8d2759692483f004c0d512a17b2b4ec6a10e6d26b3e66b8785b28a0510cc3eaf7ad029b95f0a11a37b0264dc028e3c65a5cbccffbc64e5446365cdaf9ae2ce
-  data.tar.gz: d88946c92b88073fc01f4b57ae0f13ba157ca7a72c85ae6ad405a0569b311e5420689d76014c5cda88c709b2dfbfa2dbed6b090e2c001894fdf4267686cbd87d
+  metadata.gz: a3f7e4cffe3a1bc9805097a11f6490a7de4d64daa5c893e3341b569e89296d8dde97185a89f6cd5eabbcb4d9f1156d41c913fa33365601a6bb9cdacb4d8fbf6f
+  data.tar.gz: ae1292dfb2249203ad53a0860900dc49b6b46cd618f586fae8fa549700195448824d29347fb19460ff191164420113c687711a8dbbf1b101b71f9154395824b9

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,18 +44,22 @@ 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
 
-* rake
-* minitest
 * dotcfg
-* fiber_scheduler
 
-`gem install miner_mover` will take care of the following:
+`gem install dotcfg`
+
+#### Additionally
+
+To use Fiber::Scheduler and kqueue / epoll / io_uring:
+
+* fiber_scheduler
+* io-event
 
-`gem install rake minitest dotcfg fiber_scheduler`
+`gem install fiber_scheduler io-event`
 
 ### Clone
 
@@ -71,20 +75,21 @@ Try: `rake -T` to see available [Rake tasks](Rakefile)
 ```
 $ rake -T
 
-rake alt_demo         # run all demos minus fiber_scheduler / ractor / process
-rake config           # run demo/config
-rake default          # rake test
-rake demo             # run all demos
-rake fiber            # run demo/fiber
-rake fiber_scheduler  # run demo/fiber_scheduler
-rake process_pipe     # run demo/process_pipe
-rake process_socket   # run demo/process_socket
-rake ractor           # run demo/ractor
-rake serial           # run demo/serial
+rake config           # Run demo/config.rb
+rake demo             # Run all demos
+rake fiber            # Run demo/fiber.rb
+rake fiber_scheduler  # Run demo/fiber_scheduler.rb
+rake jvm_demo         # Run JVM compatible demos
+rake process_pipe     # Run demo/process_pipe.rb
+rake process_socket   # Run demo/process_socket.rb
+rake ractor           # Run demo/ractor.rb
+rake serial           # Run demo/serial.rb
 rake test             # Run tests
-rake thread           # run demo/thread
+rake thread           # Run demo/thread.rb
 ```
 
+Try: `rake test`
+
 ## Rake Tasks
 
 Included demonstration scripts can be executed via Rake tasks.
@@ -113,36 +118,76 @@ 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
+irb(main):001:0> require 'miner_mover/worker'
+=> true
+
+irb(main):002:0> include MinerMover
 => Object
 
-irb(main):002:0> miner = Miner.new
+irb(main):003:0> miner = Miner.new
 =>
-#<MinerMover::Miner:0x00007fdd649754e8
+#<MinerMover::Miner:0x00007fbee8a3a080
 ...
 
-irb(main):003:0> miner.mine_ore
-=> 0
-
-irb(main):004:0> miner.mine_ore 5
-=> 3
-
-irb(main):005:0> miner.mine_ore 20
-=> 6483
-
-irb(main):006:0> mover = Mover.new
+irb(main):004:0> mover = Mover.new
 =>
-#<MinerMover::Mover:0x00007fdd64979930
+#<MinerMover::Mover:0x00007fbee8a8a6c0
 ...
 
-irb(main):007:0> mover.load_ore 6483
-=> 6483
-
-irb(main):008:0> mover.status
-=> "Batch 6483 / 10M 0% | Moved 0x (0M)"
+irb(main):005:0> miner.state
+=>
+{:id=>"00050720",
+ :logging=>false,
+ :debugging=>false,
+ :timer=>10200,
+ :variance=>0,
+ :depth=>5,
+ :partial_reward=>false}
+
+irb(main):006:0> mover.state
+=>
+{:id=>"00057860",
+ :logging=>false,
+ :debugging=>false,
+ :timer=>10456,
+ :variance=>0,
+ :work_type=>:cpu,
+ :batch_size=>10000000,
+ :batch=>0,
+ :batches=>0,
+ :ore_moved=>0}
+
+irb(main):007:0> miner.mine_ore
+=> 7
+
+irb(main):008:0> mover.load_ore 7
+=> 7
+
+irb(main):009:0> miner.state
+=>
+{:id=>"00050720",
+ :logging=>false,
+ :debugging=>false,
+ :timer=>28831,
+ :variance=>0,
+ :depth=>5,
+ :partial_reward=>false}
+
+irb(main):010:0> mover.state
+=>
+{:id=>"00057860",
+ :logging=>false,
+ :debugging=>false,
+ :timer=>27959,
+ :variance=>0,
+ :work_type=>:cpu,
+ :batch_size=>10000000,
+ :batch=>7,
+ :batches=>0,
+ :ore_moved=>0}
 ```
 
 ## Included scripts
@@ -165,6 +210,46 @@ multiple miners or movers.
 
 Execute via e.g. `ruby -Ilib demo/thread.rb`
 
+### Approaches
+
+#### [Serial](demo/serial.rb)
+
+One miner, one mover.  The miner mines to a depth, then loads the ore.
+When the mover has a full batch, the batch is moved while the miner waits.
+
+#### [Fibers](demo/fiber.rb)
+
+Without a Fiber Scheduler, this just changes some organizational things.
+Again, one miner, one mover.  The mover has its own fiber, and the mining
+fiber can pass ore to the moving fiber.  There is no concurrency, so the
+performance is roughly the same as before.
+
+#### [Fiber Scheduler](demo/fiber_scheduler.rb)
+
+TBD
+
+#### [Threads](demo/thread.rb)
+
+An array of mining threads and an array of moving threads.
+A single shared queue for loading ore from miners to movers.
+All threads contend for the same execution lock (GVL).
+
+#### [Ractors](demo/ractor.rb)
+
+Moving threads execute in their own ractor.
+Mining threads contend against mining threads.  Moving threads, likewise.
+
+#### [Processes with pipes](demo/process_pipe.rb)
+
+Similar to ractors, but using `Process.fork` for movers, using a pipe to send
+ore from the parent mining process.
+
+#### [Processes with sockets](demo/process_socket.rb)
+
+As above, but with Unix sockets (*not* network sockets), using any of
+`SOCK_STREAM` `SOCK_DGRAM` `SOCK_SEQPACKET` socket types.
+In all cases, ore amounts are 4 bytes so the types behave roughly equivalently.
+
 # Multitasking
 
 *Multitasking* here means "the most general sense of performing several tasks
@@ -379,11 +464,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/Rakefile

@@ -1,27 +1,43 @@
-require 'rake/testtask'
+#
+# test task
+#
 
+require 'rake/testtask'
 Rake::TestTask.new :test do |t|
   t.pattern = "test/*.rb"
   t.warning = true
 end
-
-desc "rake test"
 task default: :test
 
+#
+# demo tasks
+#
+
+if ENV['RUBYOPT'].nil? or ENV['RUBYOPT'].empty?
+  flags = ['-I', File.join(__dir__, 'lib')]
+else
+  flags = nil # subprocesses will have RUBYOPT
+end
+
+# create a rake task to run each script in demo/
 Dir['demo/*.rb'].each { |demo_path|
   name = File.basename(demo_path, '.rb')
-  desc "run demo/#{name}"
-  task(name) { sh "ruby -Ilib #{demo_path}" }
+  desc "Run #{demo_path}"
+  task(name) { ruby *flags, demo_path }
 }
 
 # jruby / truffleruby lack fiber_scheduler, Ractor, and Process#fork
-desc "run all demos minus fiber_scheduler / ractor / process"
+desc "Run JVM compatible demos"
 task jvm_demo: [:serial, :fiber, :thread]
 
-desc "run all demos"
+desc "Run all demos"
 task demo: [:serial, :fiber, :fiber_scheduler,
             :thread, :ractor, :process_pipe, :process_socket]
 
+#
+# release tasks
+#
+
 begin
   require 'buildar'
 

data/VERSION

@@ -1 +1 @@
-0.1.0.1
+0.1.2.1

data/demo/process_socket.rb

@@ -15,7 +15,7 @@ Signal.trap("INT") {
   stop_mining = true
 }
 
-socktype = [:DGRAM, :STREAM, :RAW].sample
+socktype = [:DGRAM, :STREAM, :SEQPACKET].sample
 run.log "SOCK #{socktype}"
 csock, psock = UNIXSocket.pair(socktype)
 

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

data/lib/miner_mover.rb

@@ -3,20 +3,22 @@ module MinerMover
 
   # $/ is the default line separator: "\n"
   def self.puts(str, io = $stdout, separator = LINE_SEP)
-    self.write_nonblock(io, str + separator)
+    self.write(io, str + separator)
   end
 
-  def self.write_nonblock(io, str)
+  def self.write(io, str)
+    # nonblocking write attempt; ensure the full string is written
     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
+    # blocking write if nonblocking write comes up short
+    if num_bytes < str.bytesize
+      io.write str.byteslice(num_bytes, str.bytesize - num_bytes)
+    end
+    nil
   end
 
   def self.log_fmt(timer, id, msg)

data/miner_mover.gemspec

@@ -5,11 +5,11 @@ Gem::Specification.new do |s|
   s.description = <<EOF
 Fundamentally, we have a set of miners and a set of movers. A miner takes some amount of time to mine ore, which is given to a mover. When a mover has enough ore for a full batch, the delivery takes some amount of time before more ore can be loaded.
 EOF
-    s.authors = ["Rick Hull"]
+  s.authors = ["Rick Hull"]
   s.homepage = "https://github.com/rickhull/miner_mover"
   s.license = "LGPL-3.0"
 
-  s.required_ruby_version = "~> 2"
+  s.required_ruby_version = "> 2"
 
   s.version = File.read(File.join(__dir__, 'VERSION')).chomp
 
@@ -18,16 +18,5 @@ EOF
   s.files += Dir['test/**/*.rb']
   s.files += Dir['demo/**/*.rb']
 
-  s.add_dependency "dotcfg", "~> 1.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"
+  s.add_runtime_dependency "dotcfg", "~> 1.0"
 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.2.1
 platform: ruby
 authors:
 - Rick Hull
@@ -24,76 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: buildar
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: flog
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: flay
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0'
 description: 'Fundamentally, we have a set of miners and a set of movers. A miner
   takes some amount of time to mine ore, which is given to a mover. When a mover has
   enough ore for a full batch, the delivery takes some amount of time before more
@@ -133,7 +63,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">"
     - !ruby/object:Gem::Version
       version: '2'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -141,12 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-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
+requirements: []
+rubygems_version: 3.4.4
 signing_key:
 specification_version: 4
 summary: This project provides a basic concurrency problem useful for exploring different