pwrake 2.2.9 → 2.3.0

data/lib/pwrake/queue/task_queue.rb

@@ -1,12 +1,14 @@
 require "pwrake/queue/queue_array"
 require "pwrake/queue/no_action_queue"
+require "pwrake/queue/non_locality_queue"
 
 module Pwrake
 
   class TaskQueue
 
-    def initialize(hostinfo_by_id, group_map=nil)
-      @enable_steal = true
+    def initialize(queue_class, hostinfo_by_id, group_map=nil)
+      @queue_class = Pwrake.const_get(queue_class)
+      @hostinfo_by_id = hostinfo_by_id
       @q_no_action = NoActionQueue.new
       @q_reserved = Hash.new
       def @q_reserved.first
@@ -16,137 +18,99 @@ module Pwrake
         self[keys.last]
       end
 
-      @hostinfo_by_id = hostinfo_by_id
-
-      pri = Rake.application.pwrake_options['QUEUE_PRIORITY'] || "LIHR"
+      pri = Rake.application.pwrake_options['QUEUE_PRIORITY'] || "LIFO"
       case pri
-      when /prio/i
-        @array_class = PriorityQueueArray
-      when /fifo/i
-        @array_class = FifoQueueArray # Array # Fifo
-      when /lifo/i
+      when /^fifo$/i
+        @array_class = FifoQueueArray
+      when /^lifo$/i
         @array_class = LifoQueueArray
-      when /lihr/i
+      when /^lihr$/i
         @array_class = LifoHrfQueueArray
-      when /prhr/i
-        @array_class = PriorityHrfQueueArray
-      when /rank/i
-        @array_class = RankQueueArray
       else
         raise RuntimeError,"unknown option for QUEUE_PRIORITY: "+pri
       end
       Log.debug "@array_class=#{@array_class.inspect}"
-      init_queue(group_map)
-    end
 
-    def init_queue(group_map=nil)
-      @q_input = @array_class.new(0)
-      @q_no_input = FifoQueueArray.new
-      @n_turn = 1
-    end
+      # median number of cores
+      a = @hostinfo_by_id.map{|id,host_info| host_info.ncore}.sort
+      n = a.size
+      @median_core = (n%2==0) ? (a[n/2-1]+a[n/2])/2 : a[(n-1)/2]
 
-    attr_accessor :enable_steal
+      @q = @queue_class.new(hostinfo_by_id,@array_class,@median_core,group_map)
+    end
 
-    # enq
     def enq(tw)
       if tw.nil? || tw.actions.empty?
         @q_no_action.push(tw)
       else
-        enq_body(tw)
+        @q.enq_impl(tw)
       end
     end
 
-    def enq_body(tw)
-      enq_impl(tw)
-    end
-
-    def enq_impl(tw)
-      if tw.has_input_file?
-        @q_input.push(tw)
-      else
-        @q_no_input.push(tw)
+    def deq_task(&block)
+      Log.debug "deq_task from:"+(empty? ? " (empty)" : "\n#{inspect_q}")
+      deq_noaction_task(&block)
+      deq_reserve(&block)
+      @q.deq_start
+      unless @q.empty?
+        @q.turns.each{|turn| deq_turn(turn,&block) }
       end
     end
 
     def deq_noaction_task(&block)
-      Log.debug "deq_noaction_task:"+(empty? ? " (empty)" : "\n#{inspect_q}")
       while tw = @q_no_action.shift
         Log.debug "deq_noaction: #{tw.name}"
         yield(tw)
       end
     end
 
-    def deq_task(&block) # locality version
-      Log.debug "deq_task from:"+(empty? ? " (empty)" : "\n#{inspect_q}")
-      queued = 0
-      @n_turn.times do |turn|
-        next if turn_empty?(turn)
-        queued += deq_turn(turn,&block)
+    def deq_reserve(&block)
+      @q_reserved.each do |host_info,tw|
+        n_idle = host_info.idle_cores || 0
+        n_core = tw.use_cores(host_info)
+        if n_idle >= n_core
+          @q_reserved.delete(host_info)
+          Log.debug "deq_reserve: #{tw.name} n_use_cores=#{n_core}"
+          yield(tw,host_info,n_core)
+        end
       end
     end
 
     def deq_turn(turn,&block)
-      queued = 0
-      while true
+      begin
         count = 0
         @hostinfo_by_id.each_value do |host_info|
-          #Log.debug "TaskQueue#deq_turn host_info=#{host_info.name}"
-          if turn_empty?(turn)
-            return queued
-          elsif (n_idle = host_info.idle_cores) && n_idle > 0
-            if tw = @q_reserved[host_info]
-              n_use = tw.n_used_cores(host_info)
-              if n_idle < n_use
-                next
-              end
-              @q_reserved.delete(host_info)
-              Log.debug "deq_reserve: #{tw.name} n_use_cores=#{n_use}"
-            elsif tw = deq_impl(host_info,turn)
-              n_use = tw.n_used_cores(host_info)
-              if n_idle < n_use
-                @q_reserved[host_info] = tw
-                Log.debug "reserve host: #{host_info.name} for #{tw.name} (#{n_use} cores)"
-                next
-              end
-              Log.debug "deq: #{tw.name} n_use_cores=#{n_use}"
-            end
-            if tw
-              yield(tw,host_info,n_use)
+          return if @q.turn_empty?(turn)
+          n_idle = host_info.idle_cores || 0
+          next if n_idle == 0 || @q_reserved[host_info]
+          if tw = @q.deq_impl(host_info,turn)
+            n_core = tw.use_cores(host_info)
+            if n_idle >= n_core
+              Log.debug "deq: #{tw.name} n_use_cores=#{n_core}"
+              yield(tw,host_info,n_core)
               count += 1
-              queued += 1
+            else
+              @q_reserved[host_info] = tw
+              Log.debug "reserve host: #{host_info.name} for #{tw.name} (#{n_core} cores)"
             end
           end
         end
-        break if count == 0
-      end
-      queued
-    end
-
-    def turn_empty?(turn)
-      empty?
-    end
-
-    def deq_impl(host_info=nil, turn=nil)
-      @q_no_action.shift ||
-        @q_input.shift(host_info) ||
-        @q_no_input.shift(host_info)
+      end while count > 0
     end
 
     def clear
       @q_no_action.clear
       @q_reserved.clear
-      @q_input.clear
-      @q_no_input.clear
+      @q.clear
     end
 
     def empty?
       @q_no_action.empty? &&
-        @q_reserved.empty? &&
-        @q_input.empty? &&
-        @q_no_input.empty?
+      @q_reserved.empty? &&
+      @q.empty?
     end
 
-    def _qstr(h,q)
+    def self._qstr(h,q)
       s = " #{h}: size=#{q.size} "
       case q.size
       when 0
@@ -156,20 +120,19 @@ module Pwrake
       when 2
         s << "[#{q.first.name}, #{q.last.name}]\n"
       else
-        s << "[#{q.first.name},..,#{q.last.name}]\n"
+        s << "[#{q.first.name}, .., #{q.last.name}]\n"
       end
       s
     end
 
     def inspect_q
-      _qstr("noaction",@q_no_action) +
-      _qstr("input",   @q_input) +
-      _qstr("no_input",@q_no_input) +
-      _qstr("reserved",@q_reserved)
+      TaskQueue._qstr("noaction",@q_no_action) +
+      @q.inspect_q +
+      TaskQueue._qstr("reserved",@q_reserved)
     end
 
     def drop_host(host_info)
+      @q.drop_host(host_info)
     end
-
   end
 end

data/lib/pwrake/report/parallelism.rb

@@ -61,13 +61,12 @@ module Pwrake
 
 
     def plot_parallelism(csvtable, base, fmt)
+      fimg = base+'/parallelism.'+fmt
       a = count_start_end_from_csv_table(csvtable)
-      return if a.size < 4
+      return fimg if a.size < 4
 
       #density = exec_density(a)
 
-      fimg = base+'/parallelism.'+fmt
-
       n = a.size
       i = 0
       y = 0
@@ -120,13 +119,12 @@ plot '-' w l notitle
 
 
     def plot_parallelism2(csvtable, base, fmt)
+      fimg = base+'/parallelism.'+fmt
       a = count_start_end_from_csv_table(csvtable)
-      return if a.size < 4
+      return fimg if a.size < 4
 
       density = exec_density(a)
 
-      fimg = base+'/parallelism.'+fmt
-
       n = a.size
       i = 0
       y = 0

data/lib/pwrake/task/task_algorithm.rb

@@ -20,6 +20,7 @@ module Pwrake
     def pw_search_tasks(args)
       Log.debug "#{self.class}#pw_search_tasks start, task=#{name} args=#{args.inspect}"
       cl = Pwrake.clock
+      TaskWrapper.clear_rank
       task_args = TaskArguments.new(arg_names, args)
       # not synchronize owing to fiber
       search_with_call_chain(nil, task_args, InvocationChain::EMPTY)

data/lib/pwrake/task/task_property.rb

@@ -7,8 +7,19 @@ module Pwrake
     attr_accessor :subflow
 
     def parse_description(description)
-      if /\bn_?cores?[=:]\s*([+-]?\d+)/i =~ description
-        @ncore = $1.to_i
+      if /\bn_?cores?[=:]\s*(-?[\/\d]+)/i =~ description
+        case x = $1
+        when /^\/\d+$/
+          @ncore = ('1'+x).to_r
+        when /^\d+\/\d+$/
+          @ncore = x.to_r
+        when /^-?\d+$/
+          @ncore = x.to_i
+        else
+          m = "invalid task property: ncore=#{x.inspect}"
+          Log.fatal m
+          raise RuntimeError,m
+        end
       end
       if /\bretry[=:]\s*(\d+)/i =~ description
         @retry = $1.to_i
@@ -18,9 +29,13 @@ module Pwrake
           @exclusive = true
         end
       end
+      @reserve = Rake.application.pwrake_options["RESERVE_NODE"]
       if /\breserve[=:]\s*(\S+)/i =~ description
-        if /^(y|t)/i =~ $1
+        case $1
+        when /^(y|t|on)/i
           @reserve = true
+        when /^(n|f|off)/i
+          @reserve = false
         end
       end
       if /\ballow[=:]\s*(\S+)/i =~ description
@@ -42,7 +57,6 @@ module Pwrake
           @disable_steal = true
         end
       end
-      @use_cores = nil
     end
 
     def merge(prop)
@@ -55,11 +69,39 @@ module Pwrake
       @retry = prop.retry if prop.retry
       @disable_steal = prop.disable_steal if prop.disable_steal
       @subflow = prop.subflow if prop.subflow
-      @use_cores = nil
     end
 
-    def use_cores
-      @use_cores ||= (@exclusive) ? 0 : (@ncore || 1)
+    def use_cores(arg)
+      case arg
+      when HostInfo
+        ppn = arg.ncore
+      when Integer
+        ppn = arg
+        if ppn < 1
+          raise "invalid ppn: #{ppn}"
+        end
+      else
+        raise "invalid ppn: #{ppn}"
+      end
+
+      if @exclusive
+        return ppn
+      end
+
+      case @ncore
+      when Rational
+        if @ncore > 0 && @ncore <= 1
+          return [(@ncore*ppn).to_i, 1].min
+        end
+      when 1-ppn..ppn
+        return (@ncore>0) ? @ncore : @ncore+ppn
+      when nil
+        return 1
+      end
+
+      m = "ncore=#{@ncore} is out of range of cores per node: #{ppn}"
+      Log.fatal m
+      raise RuntimeError,m
     end
 
     def accept_host(host_info)
@@ -87,19 +129,5 @@ module Pwrake
       return true
     end
 
-    def n_used_cores(host_info=nil)
-      n = use_cores
-      if n == 1
-        return 1
-      elsif host_info
-        return host_info.check_cores(n)
-      elsif n < 1
-        m = "invalid for use_cores=#{n}"
-        Log.fatal m
-        raise RuntimeError,m
-      end
-      return n
-    end
-
   end
 end

data/lib/pwrake/task/task_wrapper.rb

@@ -9,6 +9,7 @@ module Pwrake
 
     @@current_id = 1
     @@task_logger = nil
+    @@instances = []
 
     def initialize(task,task_args=nil)
       @task = task
@@ -31,14 +32,17 @@ module Pwrake
       @exec_host_id = nil
       @tried_hosts = {}
       @n_retry = @property.retry || Rake.application.pwrake_options["RETRY"] || 1
+      @@instances << self
     end
 
     def_delegators :@task, :name, :actions, :prerequisites, :subsequents
+    def_delegators :@property, :use_cores
 
     attr_reader :task, :task_id, :group, :group_id, :file_stat
     attr_reader :location
     attr_reader :assigned
     attr_reader :tried_hosts
+    attr_reader :n_used_cores
     attr_accessor :executed
     attr_accessor :exec_host, :exec_host_id
     attr_accessor :shell_id, :status
@@ -63,6 +67,11 @@ module Pwrake
       @@task_logger.close if @@task_logger
     end
 
+    def self.clear_rank
+      Log.debug "#{self}.clear_rank"
+      @@instances.each{|w| w.clear_rank}
+    end
+
     def preprocess
       @time_start = Time.now
       @clock_start = Pwrake.clock
@@ -267,11 +276,15 @@ module Pwrake
           end
           @rank = max_rank + step
         end
-        #Log.debug "Task[#{name}] rank=#{@rank.inspect}"
+        Log.debug "Task[#{name}] rank=#{@rank.inspect}"
       end
       @rank
     end
 
+    def clear_rank
+      @rank = nil
+    end
+
     def file_size
       @file_stat ? @file_stat.size : 0
     end
@@ -340,8 +353,8 @@ module Pwrake
       @priority || 0
     end
 
-    def n_used_cores(host_info=nil)
-      @n_used_cores ||= @property.n_used_cores(host_info)
+    def set_used_cores(ncore)
+      @n_used_cores = ncore
     end
 
     def acceptable_for(host_info)
@@ -354,7 +367,7 @@ module Pwrake
       if @property.reserve
         return true
       end
-      host_info.accept_core(@property.use_cores)
+      host_info.accept_core(@property.use_cores(host_info.ncore))
     end
 
     def tried_host?(host_info)

data/lib/pwrake/version.rb

@@ -1,3 +1,3 @@
 module Pwrake
-  VERSION = "2.2.9"
+  VERSION = "2.3.0"
 end