pwrake 2.2.9 → 2.3.0

data/lib/pwrake/queue/non_locality_queue.rb

@@ -0,0 +1,72 @@
+require "pwrake/queue/task_queue"
+require "pwrake/queue/queue_array"
+require "pwrake/queue/no_action_queue"
+
+module Pwrake
+
+  class NonLocalityQueue
+
+    def initialize(hostinfo_by_id, array_class, median_core, group_map=nil)
+      @hostinfo_by_id = hostinfo_by_id
+      @array_class = array_class
+      @median_core = median_core
+      @disable_rank = Rake.application.pwrake_options['DISABLE_RANK_PRIORITY']
+      Log.debug "#{self.class}: @disable_rank=#{@disable_rank.inspect}"
+      @q_input = @array_class.new(@median_core)
+      @q_no_input = FifoQueueArray.new(@median_core)
+      @turns = [0]
+    end
+
+    attr_reader :turns
+
+    def enq_impl(tw)
+      if tw.has_input_file?
+        @q_input.push(tw)
+      else
+        @q_no_input.push(tw)
+      end
+    end
+
+    def turn_empty?(turn)
+      empty?
+    end
+
+    def deq_start
+      @rank = @disable_rank ? 0 : @q_input.find_rank(@median_core)
+    end
+
+    def deq_impl(host_info, turn)
+      case turn
+      when 0
+        @q_input.shift(host_info,@rank) ||
+          @q_no_input.shift(host_info,@rank)
+      else
+        raise "invalid turn: #{turn}"
+      end
+    end
+
+    def size
+      @q_input.size +
+      @q_no_input.size
+    end
+
+    def clear
+      @q_input.clear
+      @q_no_input.clear
+    end
+
+    def empty?
+      @q_input.empty? &&
+      @q_no_input.empty?
+    end
+
+    def inspect_q
+      TaskQueue._qstr("input",   @q_input) +
+      TaskQueue._qstr("no_input",@q_no_input)
+    end
+
+    def drop_host(host_info)
+    end
+
+  end
+end

data/lib/pwrake/queue/queue_array.rb

@@ -3,227 +3,137 @@ require "pwrake/task/task_rank"
 
 module Pwrake
 
-  class PriorityQueueArray < Array
-    def initialize(n)
-      super()
-    end
-
-    def shift
-      pop
-    end
+  class QueueArray < Array
 
-    def push(t)
-      priority = t.priority
-      if empty? || last.priority <= priority
-        super(t)
-      elsif first.priority > priority
-        unshift(t)
-      else
-        lower = 0
-        upper = size-1
-        while lower+1 < upper
-          mid = ((lower + upper) / 2).to_i
-          if self[mid].priority <= priority
-            lower = mid
-          else
-            upper = mid
-          end
-        end
-        insert(upper,t)
-      end
+    def initialize(nproc)
+      @nproc = nproc
+      super()
     end
 
-    def index(t)
-      if size < 40
-        return super(t)
-      end
-      priority = t.priority
-      if last.priority < priority || first.priority > priority
-        nil
-      else
-        lower = 0
-        upper = size-1
-        while lower+1 < upper
-          mid = ((lower + upper) / 2).to_i
-          if self[mid].priority < priority
-            lower = mid
+    def shift(host_info, req_rank=0)
+      i_tried = nil
+      size.times do |i|
+        tw = q_at(i)
+        if tw.rank >= req_rank && tw.acceptable_for(host_info)
+          if tw.tried_host?(host_info)
+            i_tried ||= i
           else
-            upper = mid
+            Log.debug "#{self.class}: task=#{tw.name} i=#{i}/#{size} rank=#{tw.rank}"
+            return q_delete_at(i)
           end
         end
-        mid = upper
-        if self[mid].priority == priority
-          Log.debug "TQA#index=#{mid}, priority=#{priority}"
-          mid
-        end
       end
-    end
-  end # PriorityQueueArray
-
-
-  class LifoQueueArray < Array
-    def initialize(n_cores=nil)
-      super()
-    end
-
-    def shift(host_info=nil)
-      return super() unless host_info
-      i_tried = []
-      (size-1).downto(0) do |i|
-        tw = at(i)
-        if tw.tried_host?(host_info)
-          i_tried << i
-        elsif tw.acceptable_for(host_info)
-          return delete_at(i)
-        end
-      end
-      i_tried.each do |i|
-        tw = at(i)
-        if tw.acceptable_for(host_info)
-          return delete_at(i)
-        end
+      if i_tried
+        tw = q_at(i_tried)
+        Log.debug "#{self.class}(retry): task=#{tw.name} i=#{i_tried}/#{size} rank=#{tw.rank}"
+        return q_delete_at(i_tried)
       end
       nil
     end
-  end
 
-  class FifoQueueArray < Array
-    def initialize(n_cores=nil)
-      super()
-    end
-
-    def shift(host_info=nil)
-      return super() unless host_info
-      i_tried = []
-      size.times do |i|
-        tw = at(i)
-        if tw.tried_host?(host_info)
-          i_tried << i
-        elsif tw.acceptable_for(host_info)
-          return delete_at(i)
-        end
+    def find_rank(ncore)
+      if empty?
+        return 0
       end
-      i_tried.each do |i|
-        tw = at(i)
-        if tw.acceptable_for(host_info)
-          return delete_at(i)
+      count = []
+      size.times do |i|
+        tw = q_at(i)
+        r = tw.rank
+        c = (count[r]||0) + tw.use_cores(ncore)
+        if c >= @nproc
+          return r
         end
+        count[r] = c
       end
-      nil
+      count.size - 1
     end
-  end
 
-  class RankCounter
+  end
 
-    def initialize
-      @ntask = []
-      @nproc = 0
-      @mutex = Mutex.new
+  class LifoQueueArray < QueueArray
+    def q_at(i)
+      at(size-1-i)
     end
-
-    def add_nproc(n)
-      @mutex.synchronize do
-        @nproc += n
-      end
+    def q_delete_at(i)
+      delete_at(size-1-i)
     end
+  end
 
-    def incr(r)
-      @mutex.synchronize do
-        @ntask[r] = (@ntask[r]||0) + 1
-      end
+  class FifoQueueArray < QueueArray
+    def q_at(i)
+      at(i)
     end
-
-    def get_task
-      @mutex.synchronize do
-        (@ntask.size-1).downto(0) do |r|
-          c = @ntask[r]
-          if c && c>0
-            t = yield(c, @nproc, r)
-            #t = (c<=@n) ? pop_last_rank(r) : pop
-            if t
-              @ntask[t.rank] -= 1
-              Log.debug "RankCount rank=#{r} nproc=#{@nproc} count=#{c} t.rank=#{t.rank} t.name=#{t.name}"
-            end
-            return t
-          end
-        end
-      end
-      nil
+    def q_delete_at(i)
+      delete_at(i)
     end
   end
 
+
   # HRF mixin module
   module HrfQueue
 
-    def hrf_init(n_cores=nil)
-      @nproc = n_cores || 0
+    def hrf_init(nproc)
+      @nproc = nproc
       @count = []
     end
 
     def hrf_push(t)
       r = t.rank
-      c = @count[r]
-      @count[r] = (c) ? c+1 : 1
+      n = t.use_cores(@nproc)
+      @count[r] = (@count[r] || 0) + n
     end
 
-    def hrf_get(host_info)
-      (@count.size-1).downto(0) do |r|
+    def hrf_get(host_info, rank)
+      (@count.size-1).downto(rank) do |r|
         c = @count[r]
         if c && c>0
-          t = (c <= @nproc) ? pop_last_rank(r,host_info) : pop_super(host_info)
+          t = (c <= @nproc) ?
+            pop_last_rank(r, host_info) :
+            pop_super(host_info, rank)
           hrf_delete(t) if t
           return t
         end
       end
-      raise "no element"
+      Log.debug "#{self.class}#hrf_get: no item for rank=#{rank} @count=#{@count.inspect}"
       nil
     end
 
-    def pop_last_rank(r,host_info)
-      i_tried = []
-      (size-1).downto(0) do |i|
-        tw = at(i)
-        if tw.rank == r
+    def pop_last_rank(r, host_info)
+      i_tried = nil
+      size.times do |i|
+        tw = q_at(i)
+        if tw.rank == r && tw.acceptable_for(host_info)
           if tw.tried_host?(host_info)
-            i_tried << i
-          elsif tw.acceptable_for(host_info)
-            return delete_at(i)
+            i_tried ||= i
+          else
+            Log.debug "#{self.class}: task=#{tw.name} i=#{i}/#{size} rank=#{tw.rank}"
+            return q_delete_at(i)
           end
         end
       end
-      i_tried.each do |i|
-        tw = at(i)
-        if tw.acceptable_for(host_info)
-          return delete_at(i)
-        end
+      if i_tried
+        tw = q_at(i_tried)
+        Log.debug "#{self.class}(retry): task=#{tw.name} i=#{i_tried}/#{size} rank=#{tw.rank}"
+        return q_delete_at(i_tried)
       end
       nil
     end
 
     def hrf_delete(t)
-      @count[t.rank] -= 1
-    end
-
-    def check(t=nil)
-      sum = 0
-      @count.each{|x| sum+=x if x}
-      if size != sum
-        #$stderr.puts self.inspect
-        #$stderr.puts t.inspect if t
-        raise "sise != @count.sum"
-      end
+      @count[t.rank] -= t.use_cores(@nproc)
     end
   end
 
+
   # LIFO + HRF
   class LifoHrfQueueArray
     include HrfQueue
     extend Forwardable
-    def_delegators :@a, :empty?, :size, :first, :last, :at, :delete_at
+    def_delegators :@a, :empty?, :size, :first, :last, :q_at, :q_delete_at, :find_rank
 
-    def initialize(n_cores)
-      @a = LifoQueueArray.new
-      hrf_init(n_cores)
+    def initialize(nproc)
+      @a = LifoQueueArray.new(nproc)
+      hrf_init(nproc)
     end
 
     def push(t)
@@ -231,9 +141,9 @@ module Pwrake
       hrf_push(t)
     end
 
-    def shift(host_info=nil)
+    def shift(host_info, rank)
       return nil if empty?
-      hrf_get(host_info)
+      hrf_get(host_info, rank)
     end
 
     def delete(t)
@@ -243,155 +153,8 @@ module Pwrake
       x
     end
 
-    def pop_super(host_info)
-      @a.shift(host_info)
-    end
-  end
-
-
-  # Priority + HRF
-  class PriorityHrfQueueArray < PriorityQueueArray
-    include HrfQueue
-
-    def initialize(n)
-      super(n)
-      hrf_init(n)
-    end
-
-    def push(t)
-      super(t)
-      hrf_push(t)
-    end
-
-    def shift
-      return nil if empty?
-      hrf_get
-    end
-
-    def pop_super
-      pop
-    end
-  end
-
-
-  # Rank-Even Last In First Out
-  class RankQueueArray
-
-    def initialize(n)
-      @q = []
-      @size = 0
-      @n = (n>0) ? n : 1
-    end
-
-    def push(t)
-      r = t ? t.rank : 0
-      a = @q[r]
-      if a.nil?
-        @q[r] = a = []
-      end
-      @size += 1
-      a.push(t)
-    end
-
-    def size
-      @size
-    end
-
-    def empty?
-      @size == 0
-    end
-
-    def shift
-      if empty?
-        return nil
-      end
-      (@q.size-1).downto(0) do |i|
-        a = @q[i]
-        next if a.nil? || a.empty?
-        @size -= 1
-        if a.size <= @n
-          return pop_last_max(a)
-        else
-          return shift_weighted
-        end
-      end
-      raise "ELIFO: @q=#{@q.inspect}"
-    end
-
-    def shift_weighted
-      weight, weight_avg = RANK_STAT.rank_weight
-      wsum = 0.0
-      q = []
-      @q.each_with_index do |a,i|
-        next if a.nil? || a.empty?
-        w = weight[i]
-        w = weight_avg if w.nil?
-        # w *= a.size
-        wsum += w
-        q << [a,wsum]
-      end
-      #
-      x = rand() * wsum
-      Log.debug "shift_weighted x=#{x} wsum=#{wsum} weight=#{weight.inspect}"
-      q.each do |a,w|
-        if w > x
-          return a.pop
-        end
-      end
-      raise "ELIFO: wsum=#{wsum} x=#{x}"
-    end
-
-    def pop_last_max(a)
-      if a.size < 2
-        return a.pop
-      end
-      y_max = nil
-      i_max = nil
-      n = [@n, a.size].min
-      (-n..-1).each do |i|
-        y = a[i].input_file_size
-        if y_max.nil? || y > y_max
-          y_max = y
-          i_max = i
-        end
-      end
-      a.delete_at(i_max)
-    end
-
-    def first
-      return nil if empty?
-      @q.size.times do |i|
-        a = @q[i]
-        unless a.nil? || a.empty?
-          return a.first
-        end
-      end
-    end
-
-    def last
-      return nil if empty?
-      @q.size.times do |i|
-        a = @q[-i-1]
-        unless a.nil? || a.empty?
-          return a.last
-        end
-      end
-    end
-
-    def delete(t)
-      n = 0
-      @q.each do |a|
-        if a
-          a.delete(t)
-          n += a.size
-        end
-      end
-      @size = n
-    end
-
-    def clear
-      @q.clear
-      @size = 0
+    def pop_super(host_info, rank)
+      @a.shift(host_info, rank)
     end
   end