miner_mover 0.0.0.4 → 0.1.0.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +81 -13
- data/Rakefile +17 -2
- data/VERSION +1 -1
- data/demo/fiber.rb +11 -17
- data/demo/fiber_scheduler.rb +13 -20
- data/demo/{process.rb → process_pipe.rb} +37 -38
- data/demo/process_socket.rb +111 -0
- data/demo/ractor.rb +10 -28
- data/demo/serial.rb +8 -15
- data/demo/thread.rb +11 -21
- data/lib/miner_mover/config.rb +6 -3
- data/lib/miner_mover/run.rb +25 -8
- data/lib/miner_mover/timer.rb +67 -0
- data/lib/miner_mover/worker.rb +27 -14
- data/lib/miner_mover.rb +47 -3
- data/miner_mover.gemspec +7 -4
- metadata +15 -37
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 7d6d5e0e85b066dc78e4e6c7b86d751245f1e2b3809ab176f9b69e7047c2d330
|
|
4
|
+
data.tar.gz: cd0f57ea360871fefdb7927eddef3651a277c8e8116d41a2da085dcf02a3ed73
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 1a8d2759692483f004c0d512a17b2b4ec6a10e6d26b3e66b8785b28a0510cc3eaf7ad029b95f0a11a37b0264dc028e3c65a5cbccffbc64e5446365cdaf9ae2ce
|
|
7
|
+
data.tar.gz: d88946c92b88073fc01f4b57ae0f13ba157ca7a72c85ae6ad405a0569b311e5420689d76014c5cda88c709b2dfbfa2dbed6b090e2c001894fdf4267686cbd87d
|
data/README.md
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
[](https://github.com/rickhull/miner_mover/actions/workflows/test.yaml)
|
|
2
|
+
[](https://github.com/rickhull/miner_mover/actions/workflows/demo.yaml)
|
|
2
3
|
|
|
3
4
|
# Miner Mover
|
|
4
5
|
|
|
@@ -20,8 +21,9 @@ independent and may be randomized.
|
|
|
20
21
|
https://github.com/rickhull/miner_mover/blob/bd76ea400944aab8eab9e3ffcac85d1e28353eff/lib/miner_mover/worker.rb#L85-L99
|
|
21
22
|
|
|
22
23
|
In this case, miners are rewarded by calculating `fibonacci(depth)`, using
|
|
23
|
-
classic, inefficient fibonacci.
|
|
24
|
-
|
|
24
|
+
classic, inefficient fibonacci.
|
|
25
|
+
`fibonacci(35)` yields around 10M ore, while `fibonacci(30)` yields under
|
|
26
|
+
1M ore.
|
|
25
27
|
|
|
26
28
|
## Moving
|
|
27
29
|
|
|
@@ -42,24 +44,72 @@ configured via `:work_type`
|
|
|
42
44
|
|
|
43
45
|
## Install
|
|
44
46
|
|
|
45
|
-
You'll want to use Ruby 3.x to make the most of Fibers.
|
|
47
|
+
You'll want to use **Ruby 3.x** to make the most of Fibers.
|
|
46
48
|
|
|
47
|
-
|
|
49
|
+
### Dependencies
|
|
48
50
|
|
|
49
51
|
* rake
|
|
50
52
|
* minitest
|
|
51
|
-
* compsci
|
|
52
53
|
* dotcfg
|
|
53
54
|
* fiber_scheduler
|
|
54
55
|
|
|
55
|
-
`gem install
|
|
56
|
+
`gem install miner_mover` will take care of the following:
|
|
57
|
+
|
|
58
|
+
`gem install rake minitest dotcfg fiber_scheduler`
|
|
59
|
+
|
|
60
|
+
### Clone
|
|
61
|
+
|
|
62
|
+
```
|
|
63
|
+
git clone https://github.com/rickhull/miner_mover
|
|
64
|
+
cd miner_mover
|
|
65
|
+
```
|
|
66
|
+
|
|
67
|
+
### Try rake
|
|
68
|
+
|
|
69
|
+
Try: `rake -T` to see available [Rake tasks](Rakefile)
|
|
70
|
+
|
|
71
|
+
```
|
|
72
|
+
$ rake -T
|
|
73
|
+
|
|
74
|
+
rake alt_demo # run all demos minus fiber_scheduler / ractor / process
|
|
75
|
+
rake config # run demo/config
|
|
76
|
+
rake default # rake test
|
|
77
|
+
rake demo # run all demos
|
|
78
|
+
rake fiber # run demo/fiber
|
|
79
|
+
rake fiber_scheduler # run demo/fiber_scheduler
|
|
80
|
+
rake process_pipe # run demo/process_pipe
|
|
81
|
+
rake process_socket # run demo/process_socket
|
|
82
|
+
rake ractor # run demo/ractor
|
|
83
|
+
rake serial # run demo/serial
|
|
84
|
+
rake test # Run tests
|
|
85
|
+
rake thread # run demo/thread
|
|
86
|
+
```
|
|
87
|
+
|
|
88
|
+
## Rake Tasks
|
|
89
|
+
|
|
90
|
+
Included demonstration scripts can be executed via Rake tasks.
|
|
91
|
+
The following order is recommended:
|
|
92
|
+
|
|
93
|
+
* `rake config`
|
|
94
|
+
* `rake serial`
|
|
95
|
+
* `rake fiber`
|
|
96
|
+
* `rake fiber_scheduler`
|
|
97
|
+
* `rake thread`
|
|
98
|
+
* `rake process_pipe`
|
|
99
|
+
* `rake process_socket`
|
|
100
|
+
|
|
101
|
+
Try each task; there will be about 6 seconds worth of many lines of output
|
|
102
|
+
logging. These rake tasks correspond to the scripts within [`demo/`](demo/).
|
|
56
103
|
|
|
57
104
|
## Satisfy `LOAD_PATH`
|
|
58
105
|
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
106
|
+
Rake tasks take care of `LOAD_PATH`, so the following is
|
|
107
|
+
**only necessary when *not* using rake tasks**:
|
|
108
|
+
|
|
109
|
+
* Execute scripts and irb sessions from the project root, e.g. `~/miner_mover`
|
|
110
|
+
* Use `-I lib` as a flag to `ruby` or `irb` to update `LOAD_PATH` so that
|
|
111
|
+
`require 'miner_mover'` will work.
|
|
112
|
+
* This project does not use `require_relative`
|
|
63
113
|
|
|
64
114
|
## Exploration in `irb`
|
|
65
115
|
|
|
@@ -105,13 +155,15 @@ multitasking paradigms in Ruby.
|
|
|
105
155
|
* [`demo/fiber_scheduler.rb`](demo/fiber_scheduler.rb)
|
|
106
156
|
* [`demo/thread.rb`](demo/thread.rb)
|
|
107
157
|
* [`demo/ractor.rb`](demo/ractor.rb)
|
|
158
|
+
* [`demo/process_pipe.rb`](demo/process_pipe.rb)
|
|
159
|
+
* [`demo/process_socket.rb`](demo/process_socket.rb)
|
|
108
160
|
|
|
109
161
|
See [config/example.cfg](config/example.cfg) for configuration.
|
|
110
162
|
It will be loaded by default.
|
|
111
|
-
Note that serial.rb and fiber.rb have no concurrency and cannot use
|
|
112
|
-
miners or movers.
|
|
163
|
+
Note that `serial.rb` and `fiber.rb` have no concurrency and cannot use
|
|
164
|
+
multiple miners or movers.
|
|
113
165
|
|
|
114
|
-
Execute via e.g. `ruby -Ilib demo/
|
|
166
|
+
Execute via e.g. `ruby -Ilib demo/thread.rb`
|
|
115
167
|
|
|
116
168
|
# Multitasking
|
|
117
169
|
|
|
@@ -319,3 +371,19 @@ Ractor.receive - returns a message from the current Ractor's incoming port
|
|
|
319
371
|
Ractor.yield - current Ractor sends a message on the outgoing port
|
|
320
372
|
Ractor#take - returns the next outgoing message from a Ractor
|
|
321
373
|
```
|
|
374
|
+
|
|
375
|
+
## Processes
|
|
376
|
+
|
|
377
|
+
There are many ways to create a process in Ruby, some more useful than
|
|
378
|
+
others. My favorites:
|
|
379
|
+
|
|
380
|
+
* `Process.fork` - when called with a block, the block is only executed in the
|
|
381
|
+
child subprocess
|
|
382
|
+
* `Process.spawn` - extensive options, nonblocking, call Process.wait(pid)
|
|
383
|
+
to get the result
|
|
384
|
+
* `Open3.popen3` - for access to STDIN, STDOUT, STDERR
|
|
385
|
+
|
|
386
|
+
### IPC
|
|
387
|
+
|
|
388
|
+
* Pipes - streaming bytes: `IO.pipe`
|
|
389
|
+
* Unix sockets - messages with datagrams: `Socket.pair(:UNIX, :DGRAM, 0)`
|
data/Rakefile
CHANGED
|
@@ -5,16 +5,31 @@ Rake::TestTask.new :test do |t|
|
|
|
5
5
|
t.warning = true
|
|
6
6
|
end
|
|
7
7
|
|
|
8
|
+
desc "rake test"
|
|
8
9
|
task default: :test
|
|
9
10
|
|
|
11
|
+
Dir['demo/*.rb'].each { |demo_path|
|
|
12
|
+
name = File.basename(demo_path, '.rb')
|
|
13
|
+
desc "run demo/#{name}"
|
|
14
|
+
task(name) { sh "ruby -Ilib #{demo_path}" }
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
# jruby / truffleruby lack fiber_scheduler, Ractor, and Process#fork
|
|
18
|
+
desc "run all demos minus fiber_scheduler / ractor / process"
|
|
19
|
+
task jvm_demo: [:serial, :fiber, :thread]
|
|
20
|
+
|
|
21
|
+
desc "run all demos"
|
|
22
|
+
task demo: [:serial, :fiber, :fiber_scheduler,
|
|
23
|
+
:thread, :ractor, :process_pipe, :process_socket]
|
|
24
|
+
|
|
10
25
|
begin
|
|
11
26
|
require 'buildar'
|
|
12
27
|
|
|
13
|
-
|
|
28
|
+
Buildar.new do |b|
|
|
14
29
|
b.gemspec_file = 'miner_mover.gemspec'
|
|
15
30
|
b.version_file = 'VERSION'
|
|
16
31
|
b.use_git = true
|
|
17
32
|
end
|
|
18
33
|
rescue LoadError
|
|
19
|
-
warn "buildar tasks unavailable"
|
|
34
|
+
# warn "buildar tasks unavailable"
|
|
20
35
|
end
|
data/VERSION
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
0.
|
|
1
|
+
0.1.0.1
|
data/demo/fiber.rb
CHANGED
|
@@ -2,13 +2,13 @@ require 'miner_mover/run'
|
|
|
2
2
|
|
|
3
3
|
include MinerMover
|
|
4
4
|
|
|
5
|
-
run = Run.new.cfg_banner!(duration: 1)
|
|
6
|
-
run.
|
|
7
|
-
run.log "Starting"
|
|
5
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
6
|
+
run.timestamp!
|
|
7
|
+
run.log "Starting #{__FILE__}"
|
|
8
8
|
|
|
9
9
|
stop_mining = false
|
|
10
10
|
Signal.trap("INT") {
|
|
11
|
-
run.
|
|
11
|
+
run.timestamp!
|
|
12
12
|
run.log " *** SIGINT *** Stop Mining"
|
|
13
13
|
stop_mining = true
|
|
14
14
|
}
|
|
@@ -17,20 +17,16 @@ Signal.trap("INT") {
|
|
|
17
17
|
miner = Fiber.new(blocking: true) {
|
|
18
18
|
run.log "MINE Mining operation started [ctrl-c] to stop"
|
|
19
19
|
m = run.new_miner
|
|
20
|
-
|
|
21
20
|
ore_mined = 0
|
|
22
21
|
|
|
23
|
-
|
|
24
|
-
while !stop_mining
|
|
22
|
+
while !stop_mining # SIGINT will trigger stop_mining = true
|
|
25
23
|
ore = m.mine_ore
|
|
26
|
-
|
|
27
|
-
# send any ore mined to the mover
|
|
28
|
-
Fiber.yield ore if ore > 0
|
|
29
24
|
ore_mined += ore
|
|
25
|
+
Fiber.yield ore if ore > 0
|
|
30
26
|
|
|
31
27
|
# stop mining after a while
|
|
32
28
|
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
33
|
-
run.
|
|
29
|
+
run.timestamp!
|
|
34
30
|
m.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
35
31
|
stop_mining = true
|
|
36
32
|
end
|
|
@@ -45,16 +41,14 @@ mover = run.new_mover
|
|
|
45
41
|
run.log "MOVE Moving operation started"
|
|
46
42
|
run.log "WAIT Waiting for ore ..."
|
|
47
43
|
|
|
44
|
+
# mover pulls from the queue, loads the ore, and moves it
|
|
48
45
|
loop {
|
|
49
|
-
# pick up ore yielded by the miner
|
|
50
46
|
ore = miner.resume
|
|
51
47
|
break if ore == :quit
|
|
52
|
-
|
|
53
|
-
# load (and possibly move) the ore
|
|
54
|
-
mover.load_ore ore if ore > 0
|
|
48
|
+
mover.load_ore ore if ore > 0 # move_batch happens when a batch is full
|
|
55
49
|
}
|
|
56
50
|
|
|
57
|
-
#
|
|
51
|
+
# move any remaining ore and quit
|
|
58
52
|
mover.move_batch while mover.batch > 0
|
|
59
53
|
run.log "QUIT #{mover.status}"
|
|
60
54
|
|
|
@@ -62,4 +56,4 @@ ore_mined = miner.resume
|
|
|
62
56
|
ore_moved = mover.ore_moved
|
|
63
57
|
run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
|
|
64
58
|
run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
|
|
65
|
-
run.
|
|
59
|
+
run.timestamp!
|
data/demo/fiber_scheduler.rb
CHANGED
|
@@ -3,13 +3,13 @@ require 'fiber_scheduler'
|
|
|
3
3
|
|
|
4
4
|
include MinerMover
|
|
5
5
|
|
|
6
|
-
run = Run.new.cfg_banner!(duration: 1)
|
|
7
|
-
run.
|
|
8
|
-
run.log "Starting"
|
|
6
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
7
|
+
run.timestamp!
|
|
8
|
+
run.log "Starting #{__FILE__}"
|
|
9
9
|
|
|
10
10
|
stop_mining = false
|
|
11
11
|
Signal.trap("INT") {
|
|
12
|
-
run.
|
|
12
|
+
run.timestamp!
|
|
13
13
|
run.log " *** SIGINT *** Stop Mining"
|
|
14
14
|
stop_mining = true
|
|
15
15
|
}
|
|
@@ -35,20 +35,16 @@ FiberScheduler do
|
|
|
35
35
|
Fiber.schedule do
|
|
36
36
|
m = run.new_miner
|
|
37
37
|
m.log "MINE Miner #{i} started"
|
|
38
|
-
|
|
39
38
|
ore_mined = 0
|
|
40
39
|
|
|
41
|
-
|
|
42
|
-
while !stop_mining
|
|
40
|
+
while !stop_mining # SIGINT will trigger stop_mining = true
|
|
43
41
|
ore = m.mine_ore
|
|
44
|
-
|
|
45
|
-
# send any ore mined to the mover
|
|
46
|
-
queue.push(ore) if ore > 0
|
|
47
42
|
ore_mined += ore
|
|
43
|
+
queue.push(ore) if ore > 0
|
|
48
44
|
|
|
49
45
|
# stop mining after a while
|
|
50
46
|
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
51
|
-
run.
|
|
47
|
+
run.timestamp!
|
|
52
48
|
m.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
53
49
|
stop_mining = true
|
|
54
50
|
end
|
|
@@ -73,16 +69,14 @@ FiberScheduler do
|
|
|
73
69
|
m = run.new_mover
|
|
74
70
|
m.log "MOVE Mover #{i} started"
|
|
75
71
|
|
|
72
|
+
# movers pull from the queue, load the ore, and move it
|
|
76
73
|
loop {
|
|
77
|
-
# pick up ore from the miner until we get a :quit message
|
|
78
74
|
ore = queue.pop
|
|
79
75
|
break if ore == :quit
|
|
80
|
-
|
|
81
|
-
# load (and possibly move) the ore
|
|
82
|
-
m.load_ore ore if ore > 0
|
|
76
|
+
m.load_ore ore if ore > 0 # move_batch happens when a batch is full
|
|
83
77
|
}
|
|
84
78
|
|
|
85
|
-
#
|
|
79
|
+
# move any remaining ore and quit
|
|
86
80
|
m.move_batch while m.batch > 0
|
|
87
81
|
m.log "QUIT #{m.status}"
|
|
88
82
|
|
|
@@ -100,9 +94,8 @@ FiberScheduler do
|
|
|
100
94
|
# tell every mover to quit
|
|
101
95
|
run.num_movers.times { queue.push(:quit) }
|
|
102
96
|
|
|
103
|
-
# queue closes once it is empty
|
|
104
|
-
# should helpfully cause errors if something is out of sync
|
|
105
|
-
queue.close
|
|
97
|
+
# queue only closes once it is empty
|
|
98
|
+
queue.close # should helpfully cause errors if something is out of sync
|
|
106
99
|
end
|
|
107
100
|
end
|
|
108
101
|
|
|
@@ -114,4 +107,4 @@ total_moved += moved.pop until moved.empty?
|
|
|
114
107
|
|
|
115
108
|
run.log format("MINE %s mined (%i)", Ore.display(total_mined), total_mined)
|
|
116
109
|
run.log format("MOVE %s moved (%i)", Ore.display(total_moved), total_moved)
|
|
117
|
-
run.
|
|
110
|
+
run.timestamp!
|
|
@@ -3,22 +3,32 @@ require 'thread'
|
|
|
3
3
|
|
|
4
4
|
include MinerMover
|
|
5
5
|
|
|
6
|
-
run = Run.new.cfg_banner!(duration: 1)
|
|
7
|
-
run.
|
|
8
|
-
run.log "Starting"
|
|
6
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
7
|
+
run.timestamp!
|
|
8
|
+
run.log "Starting #{__FILE__}"
|
|
9
9
|
|
|
10
10
|
stop_mining = false
|
|
11
11
|
Signal.trap("INT") {
|
|
12
|
-
run.
|
|
12
|
+
run.timestamp!
|
|
13
13
|
run.log " *** SIGINT *** Stop Mining"
|
|
14
14
|
stop_mining = true
|
|
15
15
|
}
|
|
16
16
|
|
|
17
|
+
pipe_reader, pipe_writer = IO.pipe
|
|
18
|
+
|
|
19
|
+
def pipe_reader.pop
|
|
20
|
+
Ore.decode self.read(Ore::WORD_LENGTH)
|
|
21
|
+
end
|
|
22
|
+
|
|
23
|
+
def pipe_writer.push amt
|
|
24
|
+
self.write(Ore.encode(amt))
|
|
25
|
+
end
|
|
26
|
+
|
|
27
|
+
# the moving operation executes in its own Process
|
|
17
28
|
mover = Process.fork {
|
|
18
29
|
run.log "MOVE Moving operation started"
|
|
19
|
-
|
|
20
|
-
# mover
|
|
21
|
-
queue = Thread::Queue.new
|
|
30
|
+
pipe_writer.close # we're only using pipe_reader in this process
|
|
31
|
+
queue = Thread::Queue.new # distribute incoming ore to mover threads
|
|
22
32
|
|
|
23
33
|
# store the mover threads in an array
|
|
24
34
|
movers = Array.new(run.num_movers) { |i|
|
|
@@ -26,16 +36,11 @@ mover = Process.fork {
|
|
|
26
36
|
m = run.new_mover
|
|
27
37
|
m.log "MOVE Mover #{i} started"
|
|
28
38
|
|
|
39
|
+
# movers pull from the queue, load the ore, and move it
|
|
29
40
|
loop {
|
|
30
|
-
# a mover picks up ore from the queue
|
|
31
|
-
run.debug && m.log("POP ")
|
|
32
41
|
ore = queue.pop
|
|
33
|
-
run.debug && m.log("POPD #{ore}")
|
|
34
|
-
|
|
35
42
|
break if ore == :quit
|
|
36
|
-
|
|
37
|
-
# load (and possibly move) the ore
|
|
38
|
-
m.load_ore ore
|
|
43
|
+
m.load_ore ore # move_batch happens when a batch is full
|
|
39
44
|
}
|
|
40
45
|
|
|
41
46
|
# move any remaining ore and quit
|
|
@@ -45,22 +50,25 @@ mover = Process.fork {
|
|
|
45
50
|
}
|
|
46
51
|
}
|
|
47
52
|
|
|
53
|
+
# Miners feed this Process with ore
|
|
54
|
+
# Pass the ore into a queue for the movers
|
|
55
|
+
# When the miners say to quit, tell the movers to quit
|
|
48
56
|
run.log "WAIT Waiting for ore ..."
|
|
49
|
-
|
|
50
|
-
# TODO: pipe or unix socket for ore
|
|
51
|
-
|
|
52
|
-
TODO = :notyet
|
|
53
|
-
|
|
54
57
|
loop {
|
|
55
|
-
|
|
56
|
-
ore
|
|
57
|
-
break if ore == :quit
|
|
58
|
+
ore = pipe_reader.pop
|
|
59
|
+
break if ore == 0 # signal to quit
|
|
58
60
|
queue.push ore
|
|
59
61
|
}
|
|
62
|
+
|
|
63
|
+
# tell all the movers to quit and gather their results
|
|
64
|
+
run.num_movers.times { queue.push :quit }
|
|
65
|
+
ore_moved = movers.map { |thr| thr.value.ore_moved }.sum
|
|
66
|
+
run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
|
|
60
67
|
}
|
|
61
68
|
|
|
62
|
-
# our mining operation executes in the main
|
|
69
|
+
# our mining operation executes in the main process, here
|
|
63
70
|
run.log "MINE Mining operation started [ctrl-c] to stop"
|
|
71
|
+
pipe_reader.close # we're only using pipe_writer in this process
|
|
64
72
|
|
|
65
73
|
# store the miner threads in an array
|
|
66
74
|
miners = Array.new(run.num_miners) { |i|
|
|
@@ -69,22 +77,14 @@ miners = Array.new(run.num_miners) { |i|
|
|
|
69
77
|
m.log "MINE Miner #{i} started"
|
|
70
78
|
ore_mined = 0
|
|
71
79
|
|
|
72
|
-
|
|
73
|
-
while !stop_mining
|
|
80
|
+
while !stop_mining # SIGINT will trigger stop_mining = true
|
|
74
81
|
ore = m.mine_ore
|
|
75
|
-
|
|
76
|
-
# send any ore mined to the mover Ractor
|
|
77
|
-
if ore > 0
|
|
78
|
-
run.debug && m.log("SEND #{ore}")
|
|
79
|
-
mover.send ore
|
|
80
|
-
run.debug && m.log("SENT #{ore}")
|
|
81
|
-
end
|
|
82
|
-
|
|
83
82
|
ore_mined += ore
|
|
83
|
+
pipe_writer.push(ore) if ore > 0
|
|
84
84
|
|
|
85
85
|
# stop mining after a while
|
|
86
86
|
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
87
|
-
run.
|
|
87
|
+
run.timestamp!
|
|
88
88
|
m.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
89
89
|
stop_mining = true
|
|
90
90
|
end
|
|
@@ -101,9 +101,8 @@ ore_mined = miners.map { |thr| thr.value }.sum
|
|
|
101
101
|
run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
|
|
102
102
|
|
|
103
103
|
# tell mover to quit
|
|
104
|
-
|
|
104
|
+
pipe_writer.push 0
|
|
105
105
|
|
|
106
106
|
# wait for results
|
|
107
|
-
|
|
108
|
-
run.
|
|
109
|
-
run.timer.timestamp!
|
|
107
|
+
Process.wait
|
|
108
|
+
run.timestamp!
|
|
@@ -0,0 +1,111 @@
|
|
|
1
|
+
require 'miner_mover/run'
|
|
2
|
+
require 'thread'
|
|
3
|
+
require 'socket'
|
|
4
|
+
|
|
5
|
+
include MinerMover
|
|
6
|
+
|
|
7
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
8
|
+
run.timestamp!
|
|
9
|
+
run.log "Starting #{__FILE__}"
|
|
10
|
+
|
|
11
|
+
stop_mining = false
|
|
12
|
+
Signal.trap("INT") {
|
|
13
|
+
run.timestamp!
|
|
14
|
+
run.log " *** SIGINT *** Stop Mining"
|
|
15
|
+
stop_mining = true
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
socktype = [:DGRAM, :STREAM, :RAW].sample
|
|
19
|
+
run.log "SOCK #{socktype}"
|
|
20
|
+
csock, psock = UNIXSocket.pair(socktype)
|
|
21
|
+
|
|
22
|
+
def csock.pop
|
|
23
|
+
Ore.decode self.recv(Ore::WORD_LENGTH)
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
def psock.push amt
|
|
27
|
+
self.send(Ore.encode(amt), 0)
|
|
28
|
+
end
|
|
29
|
+
|
|
30
|
+
# the moving operation executes in its own Process
|
|
31
|
+
mover = Process.fork {
|
|
32
|
+
run.log "MOVE Moving operation started"
|
|
33
|
+
psock.close # we're only using csock in this process
|
|
34
|
+
queue = Thread::Queue.new # distribute incoming ore to mover threads
|
|
35
|
+
|
|
36
|
+
# store the mover threads in an array
|
|
37
|
+
movers = Array.new(run.num_movers) { |i|
|
|
38
|
+
Thread.new {
|
|
39
|
+
m = run.new_mover
|
|
40
|
+
m.log "MOVE Mover #{i} started"
|
|
41
|
+
|
|
42
|
+
# movers pull from the queue, load the ore, and move it
|
|
43
|
+
loop {
|
|
44
|
+
ore = queue.pop
|
|
45
|
+
break if ore == :quit
|
|
46
|
+
m.load_ore ore # move_batch happens when a batch is full
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
# move any remaining ore and quit
|
|
50
|
+
m.move_batch while m.batch > 0
|
|
51
|
+
m.log "QUIT #{m.status}"
|
|
52
|
+
m
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
# Miners feed this Process with ore
|
|
57
|
+
# Pass the ore into a queue for the movers
|
|
58
|
+
# When the miners say to quit, tell the movers to quit
|
|
59
|
+
run.log "WAIT Waiting for ore ..."
|
|
60
|
+
loop {
|
|
61
|
+
ore = csock.pop
|
|
62
|
+
break if ore == 0 # signal to quit
|
|
63
|
+
queue.push ore
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
# tell all the movers to quit and gather their results
|
|
67
|
+
run.num_movers.times { queue.push :quit }
|
|
68
|
+
ore_moved = movers.map { |thr| thr.value.ore_moved }.sum
|
|
69
|
+
run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
# our mining operation executes in the main process, here
|
|
73
|
+
run.log "MINE Mining operation started [ctrl-c] to stop"
|
|
74
|
+
csock.close # we're only using psock in this process
|
|
75
|
+
|
|
76
|
+
# store the miner threads in an array
|
|
77
|
+
miners = Array.new(run.num_miners) { |i|
|
|
78
|
+
Thread.new {
|
|
79
|
+
m = run.new_miner
|
|
80
|
+
m.log "MINE Miner #{i} started"
|
|
81
|
+
ore_mined = 0
|
|
82
|
+
|
|
83
|
+
while !stop_mining # SIGINT will trigger stop_mining = true
|
|
84
|
+
ore = m.mine_ore
|
|
85
|
+
ore_mined += ore
|
|
86
|
+
psock.push(ore) if ore > 0
|
|
87
|
+
|
|
88
|
+
# stop mining after a while
|
|
89
|
+
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
90
|
+
run.timestamp!
|
|
91
|
+
m.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
92
|
+
stop_mining = true
|
|
93
|
+
end
|
|
94
|
+
end
|
|
95
|
+
|
|
96
|
+
m.log format("MINE Miner %i finished after mining %s",
|
|
97
|
+
i, Ore.display(ore_mined))
|
|
98
|
+
ore_mined
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
# wait on all mining threads to stop
|
|
103
|
+
ore_mined = miners.map { |thr| thr.value }.sum
|
|
104
|
+
run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
|
|
105
|
+
|
|
106
|
+
# tell mover to quit
|
|
107
|
+
psock.push 0
|
|
108
|
+
|
|
109
|
+
# wait for results
|
|
110
|
+
Process.wait
|
|
111
|
+
run.timestamp!
|
data/demo/ractor.rb
CHANGED
|
@@ -3,13 +3,13 @@ require 'thread'
|
|
|
3
3
|
|
|
4
4
|
include MinerMover
|
|
5
5
|
|
|
6
|
-
run = Run.new.cfg_banner!(duration: 1)
|
|
7
|
-
run.
|
|
8
|
-
run.log "Starting"
|
|
6
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
7
|
+
run.timestamp!
|
|
8
|
+
run.log "Starting #{__FILE__}"
|
|
9
9
|
|
|
10
10
|
stop_mining = false
|
|
11
11
|
Signal.trap("INT") {
|
|
12
|
-
run.
|
|
12
|
+
run.timestamp!
|
|
13
13
|
run.log " *** SIGINT *** Stop Mining"
|
|
14
14
|
stop_mining = true
|
|
15
15
|
}
|
|
@@ -27,16 +27,11 @@ mover = Ractor.new(run) { |r|
|
|
|
27
27
|
m = r.new_mover
|
|
28
28
|
m.log "MOVE Mover #{i} started"
|
|
29
29
|
|
|
30
|
+
# movers pull from the queue, load the ore, and move it
|
|
30
31
|
loop {
|
|
31
|
-
# a mover picks up ore from the queue
|
|
32
|
-
r.debug && m.log("POP ")
|
|
33
32
|
ore = queue.pop
|
|
34
|
-
r.debug && m.log("POPD #{ore}")
|
|
35
|
-
|
|
36
33
|
break if ore == :quit
|
|
37
|
-
|
|
38
|
-
# load (and possibly move) the ore
|
|
39
|
-
m.load_ore ore
|
|
34
|
+
m.load_ore ore # move_batch happens when a batch is full
|
|
40
35
|
}
|
|
41
36
|
|
|
42
37
|
# move any remaining ore and quit
|
|
@@ -53,13 +48,8 @@ mover = Ractor.new(run) { |r|
|
|
|
53
48
|
loop {
|
|
54
49
|
# when the Ractor gets ore, push it into the queue
|
|
55
50
|
ore = Ractor.recv
|
|
56
|
-
r.debug && r.log("RECV #{ore}")
|
|
57
|
-
|
|
58
51
|
break if ore == :quit
|
|
59
|
-
|
|
60
|
-
r.debug && r.log("PUSH #{ore}")
|
|
61
52
|
queue.push ore
|
|
62
|
-
r.debug && r.log("PSHD #{ore}")
|
|
63
53
|
}
|
|
64
54
|
|
|
65
55
|
# tell all the movers to quit and gather their results
|
|
@@ -77,22 +67,14 @@ miners = Array.new(run.num_miners) { |i|
|
|
|
77
67
|
m.log "MINE Miner #{i} started"
|
|
78
68
|
ore_mined = 0
|
|
79
69
|
|
|
80
|
-
|
|
81
|
-
while !stop_mining
|
|
70
|
+
while !stop_mining # SIGINT will trigger stop_mining = true
|
|
82
71
|
ore = m.mine_ore
|
|
83
|
-
|
|
84
|
-
# send any ore mined to the mover Ractor
|
|
85
|
-
if ore > 0
|
|
86
|
-
run.debug && m.log("SEND #{ore}")
|
|
87
|
-
mover.send ore
|
|
88
|
-
run.debug && m.log("SENT #{ore}")
|
|
89
|
-
end
|
|
90
|
-
|
|
91
72
|
ore_mined += ore
|
|
73
|
+
mover.send ore if ore > 0 # send any ore mined to the mover Ractor
|
|
92
74
|
|
|
93
75
|
# stop mining after a while
|
|
94
76
|
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
95
|
-
run.
|
|
77
|
+
run.timestamp!
|
|
96
78
|
m.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
97
79
|
stop_mining = true
|
|
98
80
|
end
|
|
@@ -114,4 +96,4 @@ mover.send :quit
|
|
|
114
96
|
# wait for results
|
|
115
97
|
ore_moved = mover.take
|
|
116
98
|
run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
|
|
117
|
-
run.
|
|
99
|
+
run.timestamp!
|
data/demo/serial.rb
CHANGED
|
@@ -2,39 +2,32 @@ require 'miner_mover/run'
|
|
|
2
2
|
|
|
3
3
|
include MinerMover
|
|
4
4
|
|
|
5
|
-
run = Run.new.cfg_banner!(duration: 1)
|
|
6
|
-
run.
|
|
7
|
-
run.log "Starting"
|
|
5
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
6
|
+
run.timestamp!
|
|
7
|
+
run.log "Starting #{__FILE__}"
|
|
8
8
|
|
|
9
9
|
stop_mining = false
|
|
10
10
|
Signal.trap("INT") {
|
|
11
|
-
run.
|
|
11
|
+
run.timestamp!
|
|
12
12
|
run.log " *** SIGINT *** Stop Mining"
|
|
13
13
|
stop_mining = true
|
|
14
14
|
}
|
|
15
15
|
|
|
16
|
-
# system 'cpulimit', "--pid=#{Process.pid}", '--limit=1', '--background'
|
|
17
|
-
|
|
18
16
|
miner = run.new_miner
|
|
19
17
|
run.log "MINE Mining operation initialized [ctrl-c] to stop"
|
|
20
18
|
|
|
21
19
|
mover = run.new_mover
|
|
22
20
|
run.log "MOVE Moving operation initialized"
|
|
23
|
-
|
|
24
21
|
ore_mined = 0
|
|
25
22
|
|
|
26
|
-
|
|
27
|
-
while !stop_mining
|
|
28
|
-
# mine the ore
|
|
23
|
+
while !stop_mining # SIGINT will trigger stop_mining = true
|
|
29
24
|
ore = miner.mine_ore
|
|
30
25
|
ore_mined += ore
|
|
31
|
-
|
|
32
|
-
# load (and possibly move) the ore
|
|
33
|
-
mover.load_ore ore if ore > 0
|
|
26
|
+
mover.load_ore ore if ore > 0 # move_batch happens when a batch is full
|
|
34
27
|
|
|
35
28
|
# stop mining after a while
|
|
36
29
|
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
37
|
-
run.
|
|
30
|
+
run.timestamp!
|
|
38
31
|
miner.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
39
32
|
stop_mining = true
|
|
40
33
|
end
|
|
@@ -47,4 +40,4 @@ run.log "QUIT #{mover.status}"
|
|
|
47
40
|
ore_moved = mover.ore_moved
|
|
48
41
|
run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
|
|
49
42
|
run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
|
|
50
|
-
run.
|
|
43
|
+
run.timestamp!
|
data/demo/thread.rb
CHANGED
|
@@ -3,13 +3,13 @@ require 'thread'
|
|
|
3
3
|
|
|
4
4
|
include MinerMover
|
|
5
5
|
|
|
6
|
-
run = Run.new.cfg_banner!(duration: 1)
|
|
7
|
-
run.
|
|
8
|
-
run.log "Starting"
|
|
6
|
+
run = Run.new.cfg_banner!(duration: 1).start!
|
|
7
|
+
run.timestamp!
|
|
8
|
+
run.log "Starting #{__FILE__}"
|
|
9
9
|
|
|
10
10
|
stop_mining = false
|
|
11
11
|
Signal.trap("INT") {
|
|
12
|
-
run.
|
|
12
|
+
run.timestamp!
|
|
13
13
|
run.log " *** SIGINT *** Stop Mining"
|
|
14
14
|
stop_mining = true
|
|
15
15
|
}
|
|
@@ -24,16 +24,11 @@ movers = Array.new(run.num_movers) { |i|
|
|
|
24
24
|
m = run.new_mover
|
|
25
25
|
run.log "MOVE Mover #{i} started"
|
|
26
26
|
|
|
27
|
+
# movers pull from the queue, load the ore, and move it
|
|
27
28
|
loop {
|
|
28
|
-
# a mover picks up mined ore from the queue
|
|
29
|
-
run.debug && m.log("POP ")
|
|
30
29
|
ore = queue.pop
|
|
31
|
-
run.debug && m.log("POPD #{ore}")
|
|
32
|
-
|
|
33
30
|
break if ore == :quit
|
|
34
|
-
|
|
35
|
-
# load (and possibly move) the ore
|
|
36
|
-
m.load_ore ore
|
|
31
|
+
m.load_ore ore # moving of ore possibly happens here (on a full batch)
|
|
37
32
|
}
|
|
38
33
|
|
|
39
34
|
# move any remaining ore and quit
|
|
@@ -45,6 +40,7 @@ movers = Array.new(run.num_movers) { |i|
|
|
|
45
40
|
|
|
46
41
|
|
|
47
42
|
run.log "MINE Mining operation started [ctrl-c] to stop"
|
|
43
|
+
|
|
48
44
|
# store the miner threads in an array
|
|
49
45
|
miners = Array.new(run.num_miners) { |i|
|
|
50
46
|
Thread.new {
|
|
@@ -55,19 +51,12 @@ miners = Array.new(run.num_miners) { |i|
|
|
|
55
51
|
# miners wait for the SIGINT signal to quit
|
|
56
52
|
while !stop_mining
|
|
57
53
|
ore = m.mine_ore
|
|
58
|
-
|
|
59
|
-
# send any ore mined to the movers
|
|
60
|
-
if ore > 0
|
|
61
|
-
run.debug && m.log("PUSH #{ore}")
|
|
62
|
-
queue.push ore
|
|
63
|
-
run.debug && m.log("PSHD #{ore}")
|
|
64
|
-
end
|
|
65
|
-
|
|
66
54
|
ore_mined += ore
|
|
55
|
+
queue.push ore if ore > 0 # send any ore mined to the movers
|
|
67
56
|
|
|
68
57
|
# stop mining after a while
|
|
69
58
|
if run.time_limit? or run.ore_limit?(ore_mined)
|
|
70
|
-
run.
|
|
59
|
+
run.timestamp!
|
|
71
60
|
m.log format("Mining limit reached: %s", Ore.display(ore_mined))
|
|
72
61
|
stop_mining = true
|
|
73
62
|
end
|
|
@@ -86,6 +75,7 @@ run.log format("MINE %s mined (%i)", Ore.display(ore_mined), ore_mined)
|
|
|
86
75
|
# tell all the movers to quit; gather their results
|
|
87
76
|
run.num_movers.times { queue.push :quit }
|
|
88
77
|
|
|
78
|
+
# wait for results
|
|
89
79
|
ore_moved = movers.map { |thr| thr.value.ore_moved }.sum
|
|
90
80
|
run.log format("MOVE %s moved (%i)", Ore.display(ore_moved), ore_moved)
|
|
91
|
-
run.
|
|
81
|
+
run.timestamp!
|
data/lib/miner_mover/config.rb
CHANGED
|
@@ -14,19 +14,22 @@ module MinerMover
|
|
|
14
14
|
time_limit: 5,
|
|
15
15
|
ore_limit: 100,
|
|
16
16
|
logging: true,
|
|
17
|
+
debugging: false,
|
|
17
18
|
}.freeze,
|
|
18
19
|
miner: {
|
|
19
20
|
depth: 30,
|
|
20
21
|
partial_reward: false,
|
|
21
22
|
variance: 0,
|
|
22
23
|
logging: true,
|
|
24
|
+
debugging: false,
|
|
23
25
|
}.freeze,
|
|
24
26
|
mover: {
|
|
25
|
-
batch_size:
|
|
26
|
-
rate:
|
|
27
|
+
batch_size: 8,
|
|
28
|
+
rate: 4,
|
|
27
29
|
work_type: :wait,
|
|
28
30
|
variance: 0,
|
|
29
31
|
logging: true,
|
|
32
|
+
debugging: false,
|
|
30
33
|
}.freeze,
|
|
31
34
|
}.freeze
|
|
32
35
|
|
|
@@ -60,7 +63,7 @@ module MinerMover
|
|
|
60
63
|
mover = cfg[:mover] || {}
|
|
61
64
|
main = cfg[:main] || {}
|
|
62
65
|
else
|
|
63
|
-
|
|
66
|
+
miner, mover, main = {}, {}, {}
|
|
64
67
|
end
|
|
65
68
|
{ miner: DEFAULT[:miner].merge(miner),
|
|
66
69
|
mover: DEFAULT[:mover].merge(mover),
|
data/lib/miner_mover/run.rb
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
require 'miner_mover/worker'
|
|
2
2
|
require 'miner_mover/config'
|
|
3
|
+
require 'miner_mover/timer'
|
|
3
4
|
|
|
4
5
|
module MinerMover
|
|
5
6
|
class Run
|
|
@@ -15,35 +16,47 @@ module MinerMover
|
|
|
15
16
|
f
|
|
16
17
|
end
|
|
17
18
|
|
|
18
|
-
attr_accessor :
|
|
19
|
+
attr_accessor :debugging, :logging
|
|
19
20
|
attr_accessor :num_miners, :num_movers
|
|
20
21
|
attr_accessor :cfg_file, :cfg, :miner, :mover, :timer
|
|
21
22
|
attr_accessor :time_limit, :ore_limit
|
|
22
23
|
|
|
23
|
-
def initialize(cfg_file: nil, timer: nil
|
|
24
|
+
def initialize(cfg_file: nil, timer: nil)
|
|
24
25
|
@cfg_file = self.class.cfg_file(cfg_file)
|
|
25
26
|
@cfg = Config.process @cfg_file
|
|
26
27
|
main = @cfg.fetch :main
|
|
27
28
|
@miner = @cfg.fetch :miner
|
|
28
29
|
@mover = @cfg.fetch :mover
|
|
29
30
|
|
|
31
|
+
@num_miners = main.fetch :num_miners
|
|
32
|
+
@num_movers = main.fetch :num_movers
|
|
33
|
+
|
|
30
34
|
@time_limit = main.fetch :time_limit
|
|
31
35
|
@ore_limit = main.fetch :ore_limit
|
|
32
36
|
@logging = main.fetch :logging
|
|
33
|
-
@
|
|
34
|
-
@num_movers = main.fetch :num_movers
|
|
37
|
+
@debugging = main.fetch :debugging
|
|
35
38
|
|
|
36
|
-
@timer = timer ||
|
|
37
|
-
@debug = debug
|
|
39
|
+
@timer = timer || Timer.new
|
|
38
40
|
end
|
|
39
41
|
|
|
40
42
|
def cfg_banner!(duration: 0)
|
|
41
|
-
|
|
43
|
+
MinerMover.puts "USING: #{@cfg_file}"
|
|
42
44
|
pp @cfg
|
|
43
45
|
sleep duration if duration > 0
|
|
44
46
|
self
|
|
45
47
|
end
|
|
46
48
|
|
|
49
|
+
def start!
|
|
50
|
+
@timer.restart
|
|
51
|
+
self
|
|
52
|
+
end
|
|
53
|
+
|
|
54
|
+
def timestamp!
|
|
55
|
+
dash = '-' * 70
|
|
56
|
+
str = [dash, Timer.timestamp, dash].join(MinerMover::LINE_SEP)
|
|
57
|
+
MinerMover.puts str
|
|
58
|
+
end
|
|
59
|
+
|
|
47
60
|
def new_miner
|
|
48
61
|
Miner.new(**@miner)
|
|
49
62
|
end
|
|
@@ -61,7 +74,11 @@ module MinerMover
|
|
|
61
74
|
end
|
|
62
75
|
|
|
63
76
|
def log msg
|
|
64
|
-
@logging and
|
|
77
|
+
@logging and MinerMover.log @timer, ' (main) ', msg
|
|
78
|
+
end
|
|
79
|
+
|
|
80
|
+
def debug msg
|
|
81
|
+
@debugging and MinerMover.log @timer, '(debug) ', msg
|
|
65
82
|
end
|
|
66
83
|
end
|
|
67
84
|
end
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
module MinerMover
|
|
2
|
+
class Timer
|
|
3
|
+
SECS_PER_MIN = 60
|
|
4
|
+
MINS_PER_HOUR = 60
|
|
5
|
+
SECS_PER_HOUR = SECS_PER_MIN * MINS_PER_HOUR
|
|
6
|
+
|
|
7
|
+
# returns a float representing seconds since epoch
|
|
8
|
+
if defined? Process::CLOCK_MONOTONIC
|
|
9
|
+
def self.now
|
|
10
|
+
Process.clock_gettime Process::CLOCK_MONOTONIC
|
|
11
|
+
end
|
|
12
|
+
else
|
|
13
|
+
def self.now
|
|
14
|
+
Time.now.to_f
|
|
15
|
+
end
|
|
16
|
+
end
|
|
17
|
+
|
|
18
|
+
def self.since f
|
|
19
|
+
self.now - f
|
|
20
|
+
end
|
|
21
|
+
|
|
22
|
+
def self.elapsed &work
|
|
23
|
+
f = self.now
|
|
24
|
+
return yield, self.since(f)
|
|
25
|
+
end
|
|
26
|
+
|
|
27
|
+
# HH::MM::SS.mmm.uuuuuuuu
|
|
28
|
+
def self.elapsed_display(elapsed_ms, show_micro: false)
|
|
29
|
+
elapsed_s, ms = elapsed_ms.divmod 1000
|
|
30
|
+
ms_only, ms_fraction = ms.round(8).divmod 1
|
|
31
|
+
|
|
32
|
+
h = elapsed_s / SECS_PER_HOUR
|
|
33
|
+
elapsed_s -= h * SECS_PER_HOUR
|
|
34
|
+
m, s = elapsed_s.divmod SECS_PER_MIN
|
|
35
|
+
|
|
36
|
+
hmsms = [[h, m, s].map { |i| i.to_s.rjust(2, '0') }.join(':'),
|
|
37
|
+
ms_only.to_s.rjust(3, '0')]
|
|
38
|
+
hmsms << (ms_fraction * 10 ** 8).round.to_s.ljust(8, '0') if show_micro
|
|
39
|
+
hmsms.join('.')
|
|
40
|
+
end
|
|
41
|
+
|
|
42
|
+
# YYYY-MM-DD HH::MM::SS.mmm
|
|
43
|
+
def self.timestamp(t = Time.now)
|
|
44
|
+
t.strftime "%Y-%m-%d %H:%M:%S.%L"
|
|
45
|
+
end
|
|
46
|
+
|
|
47
|
+
def restart(t = Time.now)
|
|
48
|
+
@start = t
|
|
49
|
+
self
|
|
50
|
+
end
|
|
51
|
+
alias_method :initialize, :restart
|
|
52
|
+
|
|
53
|
+
def elapsed(t = Time.now)
|
|
54
|
+
t - @start
|
|
55
|
+
end
|
|
56
|
+
|
|
57
|
+
def elapsed_ms(t = Time.now)
|
|
58
|
+
elapsed(t) * 1000
|
|
59
|
+
end
|
|
60
|
+
|
|
61
|
+
def elapsed_display(t = Time.now)
|
|
62
|
+
Timer.elapsed_display(elapsed_ms(t))
|
|
63
|
+
end
|
|
64
|
+
alias_method :to_s, :elapsed_display
|
|
65
|
+
alias_method :inspect, :elapsed_display
|
|
66
|
+
end
|
|
67
|
+
end
|
data/lib/miner_mover/worker.rb
CHANGED
|
@@ -1,16 +1,15 @@
|
|
|
1
1
|
require 'miner_mover'
|
|
2
|
-
require '
|
|
3
|
-
require 'compsci/fibonacci'
|
|
2
|
+
require 'miner_mover/timer'
|
|
4
3
|
|
|
5
4
|
module MinerMover
|
|
6
|
-
def self.work(duration, type = :wait,
|
|
5
|
+
def self.work(duration, type = :wait, fib_target = 30)
|
|
7
6
|
case type
|
|
8
7
|
when :wait
|
|
9
8
|
sleep duration
|
|
10
9
|
duration
|
|
11
10
|
when :cpu
|
|
12
|
-
t =
|
|
13
|
-
|
|
11
|
+
t = Timer.new
|
|
12
|
+
self.fib(fib_target) while t.elapsed < duration
|
|
14
13
|
t.elapsed
|
|
15
14
|
when :instant
|
|
16
15
|
0
|
|
@@ -19,14 +18,19 @@ module MinerMover
|
|
|
19
18
|
end
|
|
20
19
|
end
|
|
21
20
|
|
|
21
|
+
def self.fib n
|
|
22
|
+
(n < 2) ? n : fib(n-1) + fib(n-2)
|
|
23
|
+
end
|
|
24
|
+
|
|
22
25
|
class Worker
|
|
23
|
-
attr_accessor :variance, :logging
|
|
26
|
+
attr_accessor :variance, :logging, :debugging
|
|
24
27
|
attr_reader :timer
|
|
25
28
|
|
|
26
|
-
def initialize(variance: 0, logging: false, timer: nil)
|
|
29
|
+
def initialize(variance: 0, logging: false, debugging: false, timer: nil)
|
|
27
30
|
@variance = variance
|
|
28
31
|
@logging = logging
|
|
29
|
-
@
|
|
32
|
+
@debugging = debugging
|
|
33
|
+
@timer = timer || Timer.new
|
|
30
34
|
end
|
|
31
35
|
|
|
32
36
|
def id
|
|
@@ -36,6 +40,7 @@ module MinerMover
|
|
|
36
40
|
def state
|
|
37
41
|
{ id: self.id,
|
|
38
42
|
logging: @logging,
|
|
43
|
+
debugging: @debugging,
|
|
39
44
|
timer: @timer.elapsed_ms.round,
|
|
40
45
|
variance: @variance }
|
|
41
46
|
end
|
|
@@ -45,7 +50,11 @@ module MinerMover
|
|
|
45
50
|
end
|
|
46
51
|
|
|
47
52
|
def log msg
|
|
48
|
-
@logging
|
|
53
|
+
@logging and MinerMover.log @timer, self.id, msg
|
|
54
|
+
end
|
|
55
|
+
|
|
56
|
+
def debug msg
|
|
57
|
+
@debugging and MinerMover.log @timer, self.id, msg
|
|
49
58
|
end
|
|
50
59
|
|
|
51
60
|
# 4 levels:
|
|
@@ -72,10 +81,12 @@ module MinerMover
|
|
|
72
81
|
partial_reward: true,
|
|
73
82
|
variance: 0,
|
|
74
83
|
logging: false,
|
|
84
|
+
debugging: false,
|
|
75
85
|
timer: nil)
|
|
76
86
|
@partial_reward = partial_reward
|
|
77
87
|
@depth = depth
|
|
78
|
-
super(variance: variance, logging: logging,
|
|
88
|
+
super(variance: variance, logging: logging,
|
|
89
|
+
debugging: debugging, timer: timer)
|
|
79
90
|
end
|
|
80
91
|
|
|
81
92
|
def state
|
|
@@ -84,11 +95,11 @@ module MinerMover
|
|
|
84
95
|
|
|
85
96
|
def mine_ore(depth = @depth)
|
|
86
97
|
log format("MINE Depth %i", depth)
|
|
87
|
-
ores, elapsed =
|
|
98
|
+
ores, elapsed = Timer.elapsed {
|
|
88
99
|
# every new depth is a new mining operation
|
|
89
100
|
Array.new(depth) { |d|
|
|
90
101
|
# mine ore by calculating fibonacci for that depth
|
|
91
|
-
mined =
|
|
102
|
+
mined = MinerMover.fib self.varied(d).round
|
|
92
103
|
@partial_reward ? rand(1 + mined) : mined
|
|
93
104
|
}
|
|
94
105
|
}
|
|
@@ -107,12 +118,14 @@ module MinerMover
|
|
|
107
118
|
work_type: :cpu,
|
|
108
119
|
variance: 0,
|
|
109
120
|
logging: false,
|
|
121
|
+
debugging: false,
|
|
110
122
|
timer: nil)
|
|
111
123
|
@batch_size = batch_size * Ore::BLOCK
|
|
112
124
|
@rate = rate.to_f * Ore::BLOCK
|
|
113
125
|
@work_type = work_type
|
|
114
126
|
@batch, @batches, @ore_moved = 0, 0, 0
|
|
115
|
-
super(variance: variance, logging: logging,
|
|
127
|
+
super(variance: variance, logging: logging,
|
|
128
|
+
debugging: debugging, timer: timer)
|
|
116
129
|
end
|
|
117
130
|
|
|
118
131
|
def state
|
|
@@ -149,7 +162,7 @@ module MinerMover
|
|
|
149
162
|
duration = self.varied(amt / @rate)
|
|
150
163
|
|
|
151
164
|
log format("MOVE %s (%.2f s)", Ore.display(amt), duration)
|
|
152
|
-
_, elapsed =
|
|
165
|
+
_, elapsed = Timer.elapsed { self.move(duration) }
|
|
153
166
|
log format("MOVD %s (%.2f s)", Ore.display(amt), elapsed)
|
|
154
167
|
|
|
155
168
|
# accounting
|
data/lib/miner_mover.rb
CHANGED
|
@@ -1,7 +1,30 @@
|
|
|
1
1
|
module MinerMover
|
|
2
|
-
|
|
2
|
+
LINE_SEP = $/.freeze
|
|
3
|
+
|
|
4
|
+
# $/ is the default line separator: "\n"
|
|
5
|
+
def self.puts(str, io = $stdout, separator = LINE_SEP)
|
|
6
|
+
self.write_nonblock(io, str + separator)
|
|
7
|
+
end
|
|
8
|
+
|
|
9
|
+
def self.write_nonblock(io, str)
|
|
10
|
+
begin
|
|
11
|
+
# nonblocking write attempt; ensure the full string is written
|
|
12
|
+
size = str.bytesize
|
|
13
|
+
num_bytes = io.write_nonblock(str)
|
|
14
|
+
# blocking write if nonblocking write comes up short
|
|
15
|
+
io.write str.byteslice(num_bytes, size - num_bytes) if num_bytes < size
|
|
16
|
+
rescue IO::WaitWritable, Errno::EINTR
|
|
17
|
+
IO.select([], [io]) # wait until writable
|
|
18
|
+
retry
|
|
19
|
+
end
|
|
20
|
+
end
|
|
21
|
+
|
|
3
22
|
def self.log_fmt(timer, id, msg)
|
|
4
|
-
format("%s %s %s", timer
|
|
23
|
+
format("%s %s %s", timer, id, msg)
|
|
24
|
+
end
|
|
25
|
+
|
|
26
|
+
def self.log(timer, id, msg)
|
|
27
|
+
self.puts self.log_fmt(timer, id, msg)
|
|
5
28
|
end
|
|
6
29
|
|
|
7
30
|
# i +- 50% at squeeze 0
|
|
@@ -18,7 +41,28 @@ module MinerMover
|
|
|
18
41
|
|
|
19
42
|
# ore is handled in blocks of 1M
|
|
20
43
|
module Ore
|
|
21
|
-
BLOCK = 1_000_000
|
|
44
|
+
BLOCK = 1_000_000 # between fib(30) and fib(31)
|
|
45
|
+
WORD_LENGTH = 4 # bytes
|
|
46
|
+
WORD_MAX = 256 ** WORD_LENGTH # up to 4.3B ore
|
|
47
|
+
HEX_UNPACK = "H#{WORD_LENGTH * 2}" # 4 bytes is 8 hex digits
|
|
48
|
+
|
|
49
|
+
# return 4 bytes, unsigned 32 bit integer, network order
|
|
50
|
+
def self.encode(ore)
|
|
51
|
+
raise "WORD_MAX overflow: #{self.block(ore)}M ore" if ore > WORD_MAX
|
|
52
|
+
[ore].pack('N')
|
|
53
|
+
end
|
|
54
|
+
|
|
55
|
+
# return an integer from the first 4 bytes
|
|
56
|
+
def self.decode(word)
|
|
57
|
+
raise "unexpected size: #{word.bytesize}" unless word.bytesize == 4
|
|
58
|
+
word.unpack('N').first
|
|
59
|
+
end
|
|
60
|
+
|
|
61
|
+
# return "0x01020304" for "\x01\x02\x03\x04"
|
|
62
|
+
def self.hex(word)
|
|
63
|
+
raise "unexpected size: #{word.bytesize}" unless word.bytesize == 4
|
|
64
|
+
"0x" + word.unpack(HEX_UNPACK).first
|
|
65
|
+
end
|
|
22
66
|
|
|
23
67
|
# raw ore in, blocks out
|
|
24
68
|
def self.block(ore, size = BLOCK)
|
data/miner_mover.gemspec
CHANGED
|
@@ -18,13 +18,16 @@ EOF
|
|
|
18
18
|
s.files += Dir['test/**/*.rb']
|
|
19
19
|
s.files += Dir['demo/**/*.rb']
|
|
20
20
|
|
|
21
|
-
s.add_dependency "compsci", "~> 0.3"
|
|
22
21
|
s.add_dependency "dotcfg", "~> 1.0"
|
|
23
|
-
s.add_dependency "fiber_scheduler", "~> 0.13"
|
|
24
22
|
|
|
25
|
-
s.
|
|
26
|
-
s.
|
|
23
|
+
s.requirements << "For all features and best performance:"
|
|
24
|
+
s.requirements << "gem install rake minitest fiber_scheduler"
|
|
25
|
+
s.requirements << "For dev tools:"
|
|
26
|
+
s.requirements << "gem install buildar flog flay"
|
|
27
|
+
|
|
27
28
|
s.add_development_dependency "rake", "~> 13.0" # CVE-2020-8130
|
|
29
|
+
s.add_development_dependency "minitest", "~> 5.0"
|
|
30
|
+
s.add_development_dependency "buildar", "~> 3.0"
|
|
28
31
|
s.add_development_dependency "flog", "~> 0"
|
|
29
32
|
s.add_development_dependency "flay", "~> 0"
|
|
30
33
|
end
|
metadata
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: miner_mover
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.
|
|
4
|
+
version: 0.1.0.1
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Rick Hull
|
|
@@ -10,20 +10,6 @@ bindir: bin
|
|
|
10
10
|
cert_chain: []
|
|
11
11
|
date: 1980-01-01 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
|
-
- !ruby/object:Gem::Dependency
|
|
14
|
-
name: compsci
|
|
15
|
-
requirement: !ruby/object:Gem::Requirement
|
|
16
|
-
requirements:
|
|
17
|
-
- - "~>"
|
|
18
|
-
- !ruby/object:Gem::Version
|
|
19
|
-
version: '0.3'
|
|
20
|
-
type: :runtime
|
|
21
|
-
prerelease: false
|
|
22
|
-
version_requirements: !ruby/object:Gem::Requirement
|
|
23
|
-
requirements:
|
|
24
|
-
- - "~>"
|
|
25
|
-
- !ruby/object:Gem::Version
|
|
26
|
-
version: '0.3'
|
|
27
13
|
- !ruby/object:Gem::Dependency
|
|
28
14
|
name: dotcfg
|
|
29
15
|
requirement: !ruby/object:Gem::Requirement
|
|
@@ -39,33 +25,19 @@ dependencies:
|
|
|
39
25
|
- !ruby/object:Gem::Version
|
|
40
26
|
version: '1.0'
|
|
41
27
|
- !ruby/object:Gem::Dependency
|
|
42
|
-
name:
|
|
43
|
-
requirement: !ruby/object:Gem::Requirement
|
|
44
|
-
requirements:
|
|
45
|
-
- - "~>"
|
|
46
|
-
- !ruby/object:Gem::Version
|
|
47
|
-
version: '0.13'
|
|
48
|
-
type: :runtime
|
|
49
|
-
prerelease: false
|
|
50
|
-
version_requirements: !ruby/object:Gem::Requirement
|
|
51
|
-
requirements:
|
|
52
|
-
- - "~>"
|
|
53
|
-
- !ruby/object:Gem::Version
|
|
54
|
-
version: '0.13'
|
|
55
|
-
- !ruby/object:Gem::Dependency
|
|
56
|
-
name: buildar
|
|
28
|
+
name: rake
|
|
57
29
|
requirement: !ruby/object:Gem::Requirement
|
|
58
30
|
requirements:
|
|
59
31
|
- - "~>"
|
|
60
32
|
- !ruby/object:Gem::Version
|
|
61
|
-
version: '
|
|
33
|
+
version: '13.0'
|
|
62
34
|
type: :development
|
|
63
35
|
prerelease: false
|
|
64
36
|
version_requirements: !ruby/object:Gem::Requirement
|
|
65
37
|
requirements:
|
|
66
38
|
- - "~>"
|
|
67
39
|
- !ruby/object:Gem::Version
|
|
68
|
-
version: '
|
|
40
|
+
version: '13.0'
|
|
69
41
|
- !ruby/object:Gem::Dependency
|
|
70
42
|
name: minitest
|
|
71
43
|
requirement: !ruby/object:Gem::Requirement
|
|
@@ -81,19 +53,19 @@ dependencies:
|
|
|
81
53
|
- !ruby/object:Gem::Version
|
|
82
54
|
version: '5.0'
|
|
83
55
|
- !ruby/object:Gem::Dependency
|
|
84
|
-
name:
|
|
56
|
+
name: buildar
|
|
85
57
|
requirement: !ruby/object:Gem::Requirement
|
|
86
58
|
requirements:
|
|
87
59
|
- - "~>"
|
|
88
60
|
- !ruby/object:Gem::Version
|
|
89
|
-
version: '
|
|
61
|
+
version: '3.0'
|
|
90
62
|
type: :development
|
|
91
63
|
prerelease: false
|
|
92
64
|
version_requirements: !ruby/object:Gem::Requirement
|
|
93
65
|
requirements:
|
|
94
66
|
- - "~>"
|
|
95
67
|
- !ruby/object:Gem::Version
|
|
96
|
-
version: '
|
|
68
|
+
version: '3.0'
|
|
97
69
|
- !ruby/object:Gem::Dependency
|
|
98
70
|
name: flog
|
|
99
71
|
requirement: !ruby/object:Gem::Requirement
|
|
@@ -139,13 +111,15 @@ files:
|
|
|
139
111
|
- demo/config.rb
|
|
140
112
|
- demo/fiber.rb
|
|
141
113
|
- demo/fiber_scheduler.rb
|
|
142
|
-
- demo/
|
|
114
|
+
- demo/process_pipe.rb
|
|
115
|
+
- demo/process_socket.rb
|
|
143
116
|
- demo/ractor.rb
|
|
144
117
|
- demo/serial.rb
|
|
145
118
|
- demo/thread.rb
|
|
146
119
|
- lib/miner_mover.rb
|
|
147
120
|
- lib/miner_mover/config.rb
|
|
148
121
|
- lib/miner_mover/run.rb
|
|
122
|
+
- lib/miner_mover/timer.rb
|
|
149
123
|
- lib/miner_mover/worker.rb
|
|
150
124
|
- miner_mover.gemspec
|
|
151
125
|
- test/miner_mover.rb
|
|
@@ -167,7 +141,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
167
141
|
- - ">="
|
|
168
142
|
- !ruby/object:Gem::Version
|
|
169
143
|
version: '0'
|
|
170
|
-
requirements:
|
|
144
|
+
requirements:
|
|
145
|
+
- 'For all features and best performance:'
|
|
146
|
+
- gem install rake minitest fiber_scheduler
|
|
147
|
+
- 'For dev tools:'
|
|
148
|
+
- gem install buildar flog flay
|
|
171
149
|
rubygems_version: 3.3.20
|
|
172
150
|
signing_key:
|
|
173
151
|
specification_version: 4
|