Module: MinerMover

Defined in:
lib/miner_mover.rb,
lib/miner_mover/run.rb,
lib/miner_mover/timer.rb,
lib/miner_mover/config.rb,
lib/miner_mover/worker.rb

Defined Under Namespace

Modules: Config, Ore Classes: Miner, Mover, Run, Timer, Worker

Constant Summary collapse

LINE_SEP = 
$/.freeze

Class Method Summary collapse

Class Method Details

.fib(n) ⇒ Object 



21
22
23
 
# File 'lib/miner_mover/worker.rb', line 21

def self.fib n
  (n < 2) ?  n  :  fib(n-1) + fib(n-2)
end

.log(timer, id, msg) ⇒ Object 



28
29
30
 
# File 'lib/miner_mover.rb', line 28

def self.log(timer, id, msg)
  self.puts self.log_fmt(timer, id, msg)
end

.log_fmt(timer, id, msg) ⇒ Object 



24
25
26
 
# File 'lib/miner_mover.rb', line 24

def self.log_fmt(timer, id, msg)
  format("%s %s %s", timer, id, msg)
end

.puts(str, io = $stdout, separator = LINE_SEP) ⇒ Object

$/ is the default line separator: “n”



5
6
7
 
# File 'lib/miner_mover.rb', line 5

def self.puts(str, io = $stdout, separator = LINE_SEP)
  self.write(io, str + separator)
end

.randomize(i, squeeze = 0) ⇒ Object

i - 50% at squeeze 0 i - 25% at squeeze 1, 12.5% at squeeze 2, etc.



34
35
36
37
38
39
40
41
42
 
# File 'lib/miner_mover.rb', line 34

def self.randomize(i, squeeze = 0)
  r, base = rand, 0.5
  # every squeeze, increase the base closer to 1 and cut the rand in half
  squeeze.times { |s|
    r *= 0.5
    base += 0.5 ** (s+2)
  }
  i * (base + r)
end

.work(duration, type = :wait, fib_target = 30) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/miner_mover/worker.rb', line 5

def self.work(duration, type = :wait, fib_target = 30)
  case type
  when :wait
    sleep duration
    duration
  when :cpu
    t = Timer.new
    self.fib(fib_target) while t.elapsed < duration
    t.elapsed
  when :instant
    0
  else
    raise "unknown work type: #{type.inspect}"
  end
end

.write(io, str) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/miner_mover.rb', line 9

def self.write(io, str)
  # nonblocking write attempt; ensure the full string is written
  begin
    num_bytes = io.write_nonblock(str)
  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