Module: Einhorn::WorkerPool

Defined in:
lib/einhorn/worker_pool.rb

Class Method Summary collapse

Class Method Details

.ack_count ⇒ Object 



76
77
78
 
# File 'lib/einhorn/worker_pool.rb', line 76

def self.ack_count
  acked_unsignaled_modern_workers.length
end

.ack_target ⇒ Object 



80
81
82
 
# File 'lib/einhorn/worker_pool.rb', line 80

def self.ack_target
  Einhorn::State.config[:number]
end

.acked_modern_workers ⇒ Object 



33
34
35
 
# File 'lib/einhorn/worker_pool.rb', line 33

def self.acked_modern_workers
  acked_modern_workers_with_state.map {|pid, _| pid}
end

.acked_modern_workers_with_state ⇒ Object 



25
26
27
 
# File 'lib/einhorn/worker_pool.rb', line 25

def self.acked_modern_workers_with_state
  modern_workers_with_state.select {|pid, spec| spec[:acked]}
end

.acked_unsignaled_modern_workers ⇒ Object 



43
44
45
46
47
 
# File 'lib/einhorn/worker_pool.rb', line 43

def self.acked_unsignaled_modern_workers
  acked_modern_workers_with_state.select do |_, spec|
    spec[:signaled].length == 0
  end.map {|pid, _| pid}
end

.missing_worker_count ⇒ Object

Use the number of modern workers, rather than unsignaled modern workers. This means if e.g. we do bunch of decs and then incs, any workers which haven’t died yet will count towards our number of workers. Since workers really should be dying shortly after they are USR2’d, that indicates a bad state and we shouldn’t make it worse by spinning up more processes. Once they die, order will be restored.



72
73
74
 
# File 'lib/einhorn/worker_pool.rb', line 72

def self.missing_worker_count
  ack_target - modern_workers.length
end

.modern_workers ⇒ Object 



29
30
31
 
# File 'lib/einhorn/worker_pool.rb', line 29

def self.modern_workers
  modern_workers_with_state.map {|pid, _| pid}
end

.modern_workers_with_state ⇒ Object 



19
20
21
22
23
 
# File 'lib/einhorn/worker_pool.rb', line 19

def self.modern_workers_with_state
  workers_with_state.select do |pid, spec|
    spec[:version] == Einhorn::State.version
  end
end

.old_workers ⇒ Object 



88
89
90
 
# File 'lib/einhorn/worker_pool.rb', line 88

def self.old_workers
  unsignaled_workers - modern_workers
end

.unacked_unsignaled_modern_workers ⇒ Object 



61
62
63
 
# File 'lib/einhorn/worker_pool.rb', line 61

def self.unacked_unsignaled_modern_workers
  unacked_unsignaled_modern_workers_with_state.map {|pid, _| pid}
end

.unacked_unsignaled_modern_workers_with_state ⇒ Object 



55
56
57
58
59
 
# File 'lib/einhorn/worker_pool.rb', line 55

def self.unacked_unsignaled_modern_workers_with_state
  modern_workers_with_state.select {|pid, spec|
    !spec[:acked] && spec[:signaled].length == 0
  }
end

.unsignaled_count ⇒ Object 



84
85
86
 
# File 'lib/einhorn/worker_pool.rb', line 84

def self.unsignaled_count
  unsignaled_modern_workers_with_state.length
end

.unsignaled_modern_workers_with_priority ⇒ Object 



49
50
51
52
53
 
# File 'lib/einhorn/worker_pool.rb', line 49

def self.unsignaled_modern_workers_with_priority
  unsignaled_modern_workers_with_state.sort_by do |pid, spec|
    spec[:acked] ? 1 : 0
  end.map {|pid, _| pid}
end

.unsignaled_modern_workers_with_state ⇒ Object 



37
38
39
40
41
 
# File 'lib/einhorn/worker_pool.rb', line 37

def self.unsignaled_modern_workers_with_state
  modern_workers_with_state.select do |_, spec|
    spec[:signaled].length == 0
  end
end

.unsignaled_workers ⇒ Object 



13
14
15
16
17
 
# File 'lib/einhorn/worker_pool.rb', line 13

def self.unsignaled_workers
  workers_with_state.select do |pid, spec|
    spec[:signaled].length == 0
  end.map {|pid, _| pid}
end

.workers ⇒ Object 



9
10
11
 
# File 'lib/einhorn/worker_pool.rb', line 9

def self.workers
  workers_with_state.map {|pid, _| pid}
end

.workers_with_state ⇒ Object 



3
4
5
6
7
 
# File 'lib/einhorn/worker_pool.rb', line 3

def self.workers_with_state
  Einhorn::State.children.select do |pid, spec|
    spec[:type] == :worker
  end
end