test_ids 0.8.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 131ee6beb6b36186d39111f96c2ba0c06d9a71fd
-  data.tar.gz: 5d4fc2e812a336213246939bf1f23b61739a35c8
+SHA256:
+  metadata.gz: c45579faaf12aa3964acd4caa219e9b3443c366d2186870a5ea86381376dbeae
+  data.tar.gz: 1cb178416379a578fa91c472ce7e4d22521a428bfc40d400ea52127b10dd1c8e
 SHA512:
-  metadata.gz: 91110e14f7c4ff5f63fdb3011abca0e3ecaf774423a1002a6a5db73ce3bdf0fd33bc31cdde8e6d3887cf4c1e5dd37c5dd8fc0112fc7ca1c096320e9bcae50530
-  data.tar.gz: fed24675c4d9754fce08d539b43039a7bda4c838c5cd5daa378d94fbcff05151a314b70a20185c514b4a15012371e5aab9fe5d9b3b0324acefe20bddbf89d37e
+  metadata.gz: cc9951b84d9f7754d3225461157b6cd7579e6745c22ec8de0bb60ab91bc51d9f48ffdecf2c136329506fde707df173ba8e238233190e4236b62793beef92c06c
+  data.tar.gz: a04f02f1207e4599a3c0cb5d986b4e28741206afaf64e530b9d47dd86849b2c4a322e1a6c35e45284d727731d2bd592b4a5f4306b9eade6ccde0087062e01272

data/config/commands.rb

@@ -33,6 +33,8 @@ when "examples", "test"
   # Program generator integration test
   ARGV = %w(program/prb1.rb -t default -e default -r approved)
   load "#{Origen.top}/lib/origen/commands/program.rb"
+  ARGV = %W(program/prb1.rb -t dut2 -o #{Origen.root}/output/dut2 -e default -r approved/dut2)
+  load "#{Origen.top}/lib/origen/commands/program.rb"
 
   if Origen.app.stats.changed_files == 0 &&
      Origen.app.stats.new_files == 0 &&

data/config/version.rb

@@ -1,8 +1,7 @@
 module TestIds
-  MAJOR = 0
-  MINOR = 8
-  BUGFIX = 2
+  MAJOR = 1
+  MINOR = 2
+  BUGFIX = 0
   DEV = nil
-
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
 end

data/lib/test_ids.rb

@@ -24,12 +24,58 @@ module TestIds
     # returned will be the same as would be injected into flow.test.
     def allocate(instance, options = {})
       opts = options.dup
+      inject_flow_id(opts)
       current_configuration.allocator.allocate(instance, opts)
       { bin: opts[:bin], bin_size: opts[:bin_size], softbin: opts[:softbin], softbin_size: opts[:softbin_size],
         number: opts[:number], number_size: opts[:number_size]
       }
     end
 
+    # Similar to allocate, but allocates a test number only, i.e. no bin or softbin
+    def allocate_number(instance, options = {})
+      opts = options.dup
+      opts[:bin] = :none
+      opts[:softbin] = :none
+      inject_flow_id(opts)
+      current_configuration.allocator.allocate(instance, opts)
+      {
+        number: opts[:number], number_size: opts[:number_size]
+      }
+    end
+
+    # Similar to allocate, but allocates a softbin number only, i.e. no bin or test number
+    def allocate_softbin(instance, options = {})
+      opts = options.dup
+      opts[:bin] = :none
+      opts[:number] = :none
+      inject_flow_id(opts)
+      current_configuration.allocator.allocate(instance, opts)
+      {
+        softbin: opts[:softbin], softbin_size: opts[:softbin_size]
+      }
+    end
+    alias_method :allocate_soft_bin, :allocate_softbin
+
+    # Similar to allocate, but allocates a bin number only, i.e. no softbin or test number
+    def allocate_bin(instance, options = {})
+      opts = options.dup
+      opts[:softbin] = :none
+      opts[:number] = :none
+      inject_flow_id(opts)
+      current_configuration.allocator.allocate(instance, opts)
+      {
+        softbin: opts[:bin], softbin_size: opts[:bin_size]
+      }
+    end
+
+    # @api private
+    def inject_flow_id(options)
+      if Origen.interface_loaded?
+        flow = Origen.interface.flow
+        options[:test_ids_flow_id] = flow.try(:top_level).try(:id) || flow.id
+      end
+    end
+
     # Load an existing allocator, which will be loaded with a configuration based on what has
     # been serialized into the database if present, otherwise it will have an empty configuration.
     # Returns nil if the given database can not be found.
@@ -47,9 +93,11 @@ module TestIds
       configuration(@configuration_id)
     end
 
-    def configuration(id)
+    def configuration(id, fail_on_missing = true)
       return @configuration[id] if @configuration && @configuration[id]
-      fail('You have to create the configuration first before you can access it')
+      if fail_on_missing
+        fail('You have to create the configuration first before you can access it')
+      end
     end
     alias_method :config, :configuration
 
@@ -73,26 +121,51 @@ module TestIds
       initialize_git
     end
 
-    ## Can be called in place of TestIDs.configure to change the configuration from
-    ## the one that was originally supplied.
-    ## It is expected that this is mainly useful for testing purposes only.
-    # def reconfigure(id = nil, options = {}, &block)
-    #  id, options = nil, id if id.is_a?(Hash)
+    # Switch the current configuration to the given ID
+    def config=(id)
+      unless @configuration[id]
+        fail "The TestIds configuration '#{id}' has not been defined yet!"
+      end
+      @configuration_id = id
+    end
 
-    #  @configuration_id = id || options[:id] || :not_specified
+    # Return an Array of configuration IDs
+    def configs
+      @configuration.ids
+    end
 
-    #  @configuration ||= {}
+    def bin_config=(id)
+      @bin_config = id
+    end
 
-    #  old = @configuration[@configuration_id]
-    #  new = Configuration.new(@configuration_id)
-    #  new.instance_variable_set('@allocator', old.allocator)
-    #  new.allocator.instance_variable_set('@config', new)
-    #  @configuration[@configuration_id] =  new
+    def bin_config
+      @bin_config ? configuration(@bin_config, false) : current_configuration
+    end
 
-    #  yield new
+    def softbin_config=(id)
+      @softbin_config = id
+    end
 
-    #  new.validate!
-    # end
+    def softbin_config
+      @softbin_config ? configuration(@softbin_config, false) : current_configuration
+    end
+
+    def number_config=(id)
+      @number_config = id
+    end
+
+    def number_config
+      @number_config ? configuration(@number_config, false) : current_configuration
+    end
+
+    # Temporarily switches the current configuration to the given ID for the
+    # duration of the given block, then switches it back to what it was
+    def with_config(id)
+      orig = @configuration_id
+      @configuration_id = id
+      yield
+      @configuration_id = orig
+    end
 
     def configured?
       !!@configuration_id
@@ -205,6 +278,9 @@ module TestIds
 
     def clear_configuration_id
       @configuration_id = nil
+      @bin_config = nil
+      @softbin_config = nil
+      @number_config = nil
     end
 
     def testing=(val)

data/lib/test_ids/allocator.rb

@@ -8,202 +8,182 @@ module TestIds
   class Allocator
     STORE_FORMAT_REVISION = 2
 
-    attr_reader :config
-
     def initialize(configuration)
       @config = configuration
     end
 
+    def config(type = nil)
+      if type
+        type = type.to_s
+        type.chop! if type[-1] == 's'
+        TestIds.send("#{type}_config") || @config
+      else
+        @config
+      end
+    end
+
     # Allocates a softbin number from the range specified in the test flow
     # It also keeps a track of the last softbin assigned out from a particular range
     # and uses that to increment the pointers accordingly.
     # If a numeric number is passed to the softbin, it uses that number.
     # The configuration for the TestId plugin needs to pass in the bin number and the options from the test flow
     # For this method to work as intended.
-    def next_in_range(range, options)
-      range_item(range, options)
+    # This will handle the following range inputs:
+    #   - Range, Ex: 0..10
+    #   - Array, Ex: [0..10, 20..30]
+    def next_in_range(range_definition, options)
+      if range_definition.is_a?(Range)
+        range = range_definition.to_a
+      elsif range_definition.is_a?(Array)
+        range = []
+        range_definition.each do |range_element|
+          range += range_element.is_a?(Integer) ? [range_element] : range_element.step(options[:size]).to_a
+        end
+        if range.uniq.size != range.size
+          Origen.log.error "Duplicate or overlapping range has been detected in configuration: \'#{TestIds.current_configuration.id}\'."
+          fail
+        end
+      end
+      range_item(range, range_definition, options)
     end
 
-    def range_item(range, options)
-      orig_options = options.dup
-      # Now Check if the database (JSON file) exists.
-      # If file exists, load the database and create the alias for ['pointer']['ranges']
-      if file && File.exist?(file)
-        lines = File.readlines(file)
-        # Remove any header comment lines since these are not valid JSON
-        lines.shift while lines.first =~ /^\/\// && !lines.empty?
-        s = JSON.load(lines.join("\n"))
-        rangehash = s['pointers']['ranges']
-        rangehash = Hash[rangehash.map { |k, v| [k.to_sym, v] }]
+    def range_item(range, range_definition, options)
+      # This is the actual fix, it should now not be dependent on the json file being read in, instead the store pointers
+      # will be utilized to get the correct number assigned from the range.
+      if store['pointers']['ranges'].nil?
+        rangehash = {}
       else
-        # Create an alias for the databse that stores the pointers per range
-        rangehash = store['pointers']['ranges'] ||= {}
+        rangehash = store['pointers']['ranges']
+        rangehash = Hash[rangehash.map { |k, v| [k.to_sym, v] }]
       end
+      orig_options = options.dup
       # Check the database to see if the passed in range has already been included in the database hash
-      if rangehash.key?(:"#{range}")
+      if rangehash.key?(:"#{range_definition}")
         # Read out the database hash to see what the last_softbin given out was for that range.
         # This hash is updated whenever a new softbin is assigned, so it should have the updated values for each range.
-        previous_assigned_value = rangehash[:"#{range}"].to_i
+        previous_assigned_value = rangehash[:"#{range_definition}"].to_i
         # Now calculate the new pointer.
-        @pointer = previous_assigned_value - range.min
+        @pointer = range.index(previous_assigned_value) + 1
         # Check if the last_softbin given out is the same as the range[@pointer],
         # if so increment pointer by softbin size, default size is 1, config.softbins.size is configurable.
         # from example above, pointer was calculated as 1,range[1] is 10101 and is same as last_softbin, so pointer is incremented
         # and new value is assigned to the softbin.
-        if previous_assigned_value == range.to_a[@pointer]
+        if previous_assigned_value == range[@pointer]
           @pointer += options[:size]
-          assigned_value = range.to_a[@pointer]
+          assigned_value = range[@pointer]
         else
           # Because of the pointer calculations above, I don't think it will ever reach here, has not in my test cases so far!
-          assigned_value = range.to_a[@pointer]
+          assigned_value = range[@pointer]
         end
         # Now update the database pointers to point to the lastest assigned softbin for a given range.
-        rangehash.merge!(:"#{range}" => "#{range.to_a[@pointer]}")
+        rangehash.merge!(:"#{range_definition}" => "#{range[@pointer]}")
       else
         # This is the case for a brand new range that has not been passed before
         # We start from the first value as the assigned softbin and update the database to reflect.
         @pointer = 0
-        rangehash.merge!(:"#{range}" => "#{range.to_a[@pointer]}")
-        assigned_value = range.to_a[@pointer]
+        rangehash.merge!(:"#{range_definition}" => "#{range[@pointer]}")
+        assigned_value = range[@pointer]
       end
-      unless !assigned_value.nil? && assigned_value.between?(range.min, range.max)
+      unless !assigned_value.nil? && range.include?(assigned_value)
         Origen.log.error 'Assigned value not in range'
         fail
       end
+      # Since the assigned value for this test has now changed, update store to contain the newly assigned value
+      # so that when the json file is written, it contains the latest assigned value name.
+      store['pointers']['ranges'] = rangehash
       assigned_value
     end
 
-    # Main method to inject generated bin and test numbers, the given
-    # options instance is modified accordingly
-    def allocate(instance, options)
-      orig_options = options.dup
-      clean(options)
-      @callbacks = []
-      name = extract_test_name(instance, options)
-      name = "#{name}_#{options[:index]}" if options[:index]
-
-      # First work out the test ID to be used for each of the numbers, and how many numbers
-      # should be reserved
-      if (options[:bin].is_a?(Symbol) || options[:bin].is_a?(String)) && options[:bin] != :none
-        bin_id = options[:bin].to_s
+    # Returns an array containing :bin, :softbin, :number in the order that they should be calculated in order to fulfil
+    # the requirements of the current configuration and the given options.
+    # If an item is not required (e.g. if set to :none in the options), then it will not be present in the array.
+    def allocation_order(options)
+      items = []
+      items_required = 0
+      if allocation_required?(:bin, options) ||
+         (allocation_required?(:softbin, options) && config(:softbin).softbins.needs?(:bin)) ||
+         (allocation_required?(:number, options) && config(:number).numbers.needs?(:bin))
+        items_required += 1
       else
-        bin_id = name
+        bin_done = true
       end
-      if (options[:softbin].is_a?(Symbol) || options[:softbin].is_a?(String)) && options[:softbin] != :none
-        softbin_id = options[:softbin].to_s
+      if allocation_required?(:softbin, options) ||
+         (allocation_required?(:bin, options) && config(:bin).bins.needs?(:softbin)) ||
+         (allocation_required?(:number, options) && config(:number).numbers.needs?(:softbin))
+        items_required += 1
       else
-        softbin_id = name
+        softbin_done = true
       end
-      if (options[:number].is_a?(Symbol) || options[:number].is_a?(String)) && options[:number] != :none
-        number_id = options[:number].to_s
+      if allocation_required?(:number, options) ||
+         (allocation_required?(:bin, options) && config(:bin).bins.needs?(:number)) ||
+         (allocation_required?(:softbin, options) && config(:softbin).softbins.needs?(:number))
+        items_required += 1
       else
-        number_id = name
-      end
-
-      bin_size = options[:bin_size] || config.bins.size
-      softbin_size = options[:softbin_size] || config.softbins.size
-      number_size = options[:number_size] || config.numbers.size
-
-      bin = store['assigned']['bins'][bin_id] ||= {}
-      softbin = store['assigned']['softbins'][softbin_id] ||= {}
-      number = store['assigned']['numbers'][number_id] ||= {}
-
-      # If the user has supplied any of these, that number should be used
-      # and reserved so that it is not automatically generated later
-      if options[:bin] && options[:bin].is_a?(Numeric)
-        bin['number'] = options[:bin]
-        bin['size'] = bin_size
-        store['manually_assigned']['bins'][options[:bin].to_s] = true
-      # Regenerate the bin if the original allocation has since been applied
-      # manually elsewhere
-      elsif store['manually_assigned']['bins'][bin['number'].to_s]
-        bin['number'] = nil
-        bin['size'] = nil
-        # Also regenerate these as they could be a function of the bin
-        if config.softbins.function?
-          softbin['number'] = nil
-          softbin['size'] = nil
-        end
-        if config.numbers.function?
-          number['number'] = nil
-          number['size'] = nil
-        end
-      end
-      if options[:softbin] && options[:softbin].is_a?(Numeric)
-        softbin['number'] = options[:softbin]
-        softbin['size'] = softbin_size
-        store['manually_assigned']['softbins'][options[:softbin].to_s] = true
-      elsif store['manually_assigned']['softbins'][softbin['number'].to_s]
-        softbin['number'] = nil
-        softbin['size'] = nil
-        # Also regenerate the number as it could be a function of the softbin
-        if config.numbers.function?
-          number['number'] = nil
-          number['size'] = nil
-        end
-      end
-      if options[:number] && options[:number].is_a?(Numeric)
-        number['number'] = options[:number]
-        number['size'] = number_size
-        store['manually_assigned']['numbers'][options[:number].to_s] = true
-      elsif store['manually_assigned']['numbers'][number['number'].to_s]
-        number['number'] = nil
-        number['size'] = nil
-        # Also regenerate the softbin as it could be a function of the number
-        if config.softbins.function?
-          softbin['number'] = nil
-          softbin['size'] = nil
+        number_done = true
+      end
+      items_required.times do |i|
+        if !bin_done && (!config(:bin).bins.needs?(:softbin) || softbin_done) && (!config(:bin).bins.needs?(:number) || number_done)
+          items << :bin
+          bin_done = true
+        elsif !softbin_done && (!config(:softbin).softbins.needs?(:bin) || bin_done) && (!config(:softbin).softbins.needs?(:number) || number_done)
+          items << :softbin
+          softbin_done = true
+        elsif !number_done && (!config(:number).numbers.needs?(:bin) || bin_done) && (!config(:number).numbers.needs?(:softbin) || softbin_done)
+          items << :number
+          number_done = true
+        else
+          fail "Couldn't work out whether to generate next on iteration #{i} of #{items_required}, already picked: #{items}"
         end
       end
+      items
+    end
 
-      # Otherwise generate the missing ones
-      bin['number'] ||= allocate_bin(options.merge(size: bin_size))
-      bin['size'] ||= bin_size
-      # If the softbin is based on the test number, then need to calculate the
-      # test number first.
-      # Also do the number first if the softbin is a callback and the number is not.
-      if (config.softbins.algorithm && config.softbins.algorithm.to_s =~ /n/) ||
-         (config.softbins.callback && !config.numbers.function?)
-        number['number'] ||= allocate_number(options.merge(bin: bin['number'], size: number_size))
-        number['size'] ||= number_size
-        softbin['number'] ||= allocate_softbin(options.merge(bin: bin['number'], number: number['number'], size: softbin_size))
-        softbin['size'] ||= softbin_size
-      else
-        softbin['number'] ||= allocate_softbin(options.merge(bin: bin['number'], size: softbin_size))
-        softbin['size'] ||= softbin_size
-        number['number'] ||= allocate_number(options.merge(bin: bin['number'], softbin: softbin['number'], size: number_size))
-        number['size'] ||= number_size
-      end
+    # Main method to inject generated bin and test numbers, the given
+    # options instance is modified accordingly
+    def allocate(instance, options)
+      orig_options = options.dup
+      clean(options)
+      name = extract_test_name(instance, options)
 
-      # Record that there has been a reference to the final numbers
-      time = Time.now.to_f
-      bin_size.times do |i|
-        store['references']['bins'][(bin['number'] + i).to_s] = time if bin['number'] && options[:bin] != :none
-      end
-      softbin_size.times do |i|
-        store['references']['softbins'][(softbin['number'] + i).to_s] = time if softbin['number'] && options[:softbin] != :none
-      end
-      number_size.times do |i|
-        store['references']['numbers'][(number['number'] + i).to_s] = time if number['number'] && options[:number] != :none
-      end
+      nones = []
 
-      # Update the supplied options hash that will be forwarded to the program generator
-      unless options.delete(:bin) == :none
-        options[:bin] = bin['number']
-        options[:bin_size] = bin['size']
+      # Record any :nones that are present for later
+      [:bin, :softbin, :number].each do |type|
+        nones << type if options[type] == :none
+        config(type).allocator.instance_variable_set('@needs_regenerated', {})
       end
-      unless options.delete(:softbin) == :none
-        options[:softbin] = softbin['number']
-        options[:softbin_size] = softbin['size']
+
+      allocation_order(options).each do |type|
+        config(type).allocator.send(:_allocate, type, name, options)
       end
-      unless options.delete(:number) == :none
-        options[:number] = number['number']
-        options[:number_size] = number['size']
+
+      # Turn any :nones into nils in the returned options
+      nones.each do |type|
+        options[type] = nil
+        options["#{type}_size"] = nil
       end
 
       options
     end
 
+    # Merge the given other store into the current one, it is assumed that both are formatted
+    # from the same (latest) revision
+    def merge_store(other_store)
+      store['pointers'] = store['pointers'].merge(other_store['pointers'])
+      @last_bin = store['pointers']['bins']
+      @last_softbin = store['pointers']['softbins']
+      @last_number = store['pointers']['numbers']
+      store['assigned']['bins'] = store['assigned']['bins'].merge(other_store['assigned']['bins'])
+      store['assigned']['softbins'] = store['assigned']['softbins'].merge(other_store['assigned']['softbins'])
+      store['assigned']['numbers'] = store['assigned']['numbers'].merge(other_store['assigned']['numbers'])
+      store['manually_assigned']['bins'] = store['manually_assigned']['bins'].merge(other_store['manually_assigned']['bins'])
+      store['manually_assigned']['softbins'] = store['manually_assigned']['softbins'].merge(other_store['manually_assigned']['softbins'])
+      store['manually_assigned']['numbers'] = store['manually_assigned']['numbers'].merge(other_store['manually_assigned']['numbers'])
+      store['references']['bins'] = store['references']['bins'].merge(other_store['references']['bins'])
+      store['references']['softbins'] = store['references']['softbins'].merge(other_store['references']['softbins'])
+      store['references']['numbers'] = store['references']['numbers'].merge(other_store['references']['numbers'])
+    end
+
     def store
       @store ||= begin
         if file && File.exist?(file)
@@ -267,7 +247,7 @@ module TestIds
       { 'bins' => 'bins', 'softbins' => 'softbins', 'numbers' => 'test_numbers' }.each do |type, name|
         if !config.send(type).function? && store['pointers'][type] == 'done'
           Origen.log.info "Checking for missing #{name}..."
-          recovered = add_missing_references(config.send(type), store['references'][type])
+          recovered = add_missing_references(config.send, store['references'][type])
           if recovered == 0
             Origen.log.info "  All #{name} are already available."
           else
@@ -396,6 +376,72 @@ module TestIds
 
     private
 
+    def _allocate(type, name, options)
+      type_plural = "#{type}s"
+      conf = config.send(type_plural)
+
+      # First work out the test ID to be used for each of the numbers, and how many numbers
+      # should be reserved
+      if (options[type].is_a?(Symbol) || options[type].is_a?(String)) && options[type] != :none
+        id = options[type].to_s
+      else
+        id = name
+      end
+      id = "#{id}_#{options[:index]}" if options[:index]
+      id = "#{id}_#{options[:test_ids_flow_id]}" if config.unique_by_flow?
+
+      val = store['assigned'][type_plural][id] ||= {}
+
+      if options[type].is_a?(Integer)
+        unless val['number'] == options[type]
+          store['manually_assigned']["#{type}s"][options[type].to_s] = true
+          val['number'] = options[type]
+        end
+      else
+        # Will be set if an upstream dependent type has been marked for regeneration by the code below
+        if @needs_regenerated[type]
+          val['number'] = nil
+          val['size'] = nil
+        # Regenerate the number if the original allocation has since been applied manually elsewhere
+        elsif store['manually_assigned'][type_plural][val['number'].to_s]
+          val['number'] = nil
+          val['size'] = nil
+          # Also regenerate these as they could be a function of the number we just invalidated
+          ([:bin, :softbin, :number] - [type]).each do |t|
+            if config.send("#{t}s").needs?(type)
+              @needs_regenerated[t] = true
+            end
+          end
+        end
+      end
+
+      if size = options["#{type}_size".to_sym]
+        val['size'] = size
+      end
+
+      # Generate the missing ones
+      val['size'] ||= conf.size
+      val['number'] ||= allocate_item(type, options.merge(size: val['size']))
+
+      # Record that there has been a reference to the final numbers
+      time = Time.now.to_f
+      val['size'].times do |i|
+        store['references'][type_plural][(val['number'] + i).to_s] = time if val['number'] && options[type] != :none
+      end
+
+      # Update the supplied options hash that will be forwarded to the program generator
+      options[type] = val['number']
+      options["#{type}_size".to_sym] = val['size']
+    end
+
+    def allocation_required?(type, options)
+      if options[type] == :none
+        false
+      else
+        !config(type).send("#{type}s").empty?
+      end
+    end
+
     def remove_invalid_references(config_item, references, manually_assigned)
       removed = 0
       references.each do |num, time|
@@ -435,161 +481,34 @@ module TestIds
       recovered
     end
 
-    # Returns the next available bin in the pool, if they have all been given out
-    # the one that hasn't been used for the longest time will be given out
-    def allocate_bin(options)
-      # Not sure if this is the right way. IMO the following are true:
-      # 1. config.bins will have a callback only when ranges are specified.
-      # 2. If config.bins is empty but config.bins is not a callback, return nil to maintain functionality as before.
-      return nil if config.bins.empty? && !config.bins.callback
-      if store['pointers']['bins'] == 'done'
-        reclaim_bin(options)
-      elsif callback = config.bins.callback
-        callback.call(options)
-      else
-        b = config.bins.include.next(after: @last_bin, size: options[:size])
-        @last_bin = nil
-        while b && (store['manually_assigned']['bins'][b.to_s] || config.bins.exclude.include?(b))
-          b = config.bins.include.next(size: options[:size])
-        end
-        # When no bin is returned it means we have used them all, all future generation
-        # now switches to reclaim mode
-        if b
-          store['pointers']['bins'] = b
-        else
-          store['pointers']['bins'] = 'done'
-          reclaim_bin(options)
-        end
-      end
-    end
-
-    def reclaim_bin(options)
-      store['references']['bins'] = store['references']['bins'].sort_by { |k, v| v }.to_h
-      if options[:size] == 1
-        store['references']['bins'].first[0].to_i
-      else
-        reclaim(store['references']['bins'], options)
-      end
-    end
-
-    def allocate_softbin(options)
-      bin = options[:bin]
-      num = options[:number]
-      return nil if config.softbins.empty?
-      if config.softbins.algorithm
-        algo = config.softbins.algorithm.to_s.downcase
-        if algo.to_s =~ /^[b\dxn]+$/
+    def allocate_item(type, options)
+      type_plural = "#{type}s"
+      conf = config.send(type_plural)
+      if conf.algorithm
+        algo = conf.algorithm.to_s.downcase
+        if algo.to_s =~ /^[bsn\dx]+$/
           number = algo.to_s
-          bin = bin.to_s
-          if number =~ /(b+)/
-            max_bin_size = Regexp.last_match(1).size
-            if bin.size > max_bin_size
-              fail "Bin number (#{bin}) overflows the softbin number algorithm (#{algo})"
-            end
-            number = number.sub(/b+/, bin.rjust(max_bin_size, '0'))
-          end
-          if number =~ /(n+)/
-            num = num.to_s
-            max_num_size = Regexp.last_match(1).size
-            if num.size > max_num_size
-              fail "Test number (#{num}) overflows the softbin number algorithm (#{algo})"
-            end
-            number = number.sub(/n+/, num.rjust(max_num_size, '0'))
-          end
-          if number =~ /(x+)/
-            max_counter_size = Regexp.last_match(1).size
-            refs = store['references']['softbins']
-            i = 0
-            possible = []
-            proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0'))
-            possible << proposal
-            while refs[proposal] && i.to_s.size <= max_counter_size
-              i += 1
-              proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0'))
-              possible << proposal
-            end
-            # Overflowed, need to go search for the oldest duplicate now
-            if i.to_s.size > max_counter_size
-              i = 0
-              # Not the most efficient search algorithm, but this should be hit very rarely
-              # and even then only to generate the bin the first time around
-              p = refs.sort_by { |bin, last_used| last_used }.find do |bin, last_used|
-                possible.include?(bin)
+          ([:bin, :softbin, :number] - [type]).each do |t|
+            if number =~ /(#{t.to_s[0]}+)/
+              max_size = Regexp.last_match(1).size
+              num = options[t].to_s
+              if num.size > max_size
+                fail "The allocated number, #{num}, overflows the #{t} field in the #{type} algorithm - #{algo}"
               end
-              proposal = p[0]
+              number = number.sub(/#{t.to_s[0]}+/, num.rjust(max_size, '0'))
             end
-            number = proposal
           end
-        else
-          fail "Unknown softbin algorithm: #{algo}"
-        end
-        number.to_i
-      elsif callback = config.softbins.callback
-        callback.call(bin, options)
-      else
-        if store['pointers']['softbins'] == 'done'
-          reclaim_softbin(options)
-        else
-          b = config.softbins.include.next(after: @last_softbin, size: options[:size])
-          @last_softbin = nil
-          while b && (store['manually_assigned']['softbins'][b.to_s] || config.softbins.exclude.include?(b))
-            b = config.softbins.include.next(size: options[:size])
-          end
-          # When no softbin is returned it means we have used them all, all future generation
-          # now switches to reclaim mode
-          if b
-            store['pointers']['softbins'] = b
-          else
-            store['pointers']['softbins'] = 'done'
-            reclaim_softbin(options)
-          end
-        end
-      end
-    end
-
-    def reclaim_softbin(options)
-      store['references']['softbins'] = store['references']['softbins'].sort_by { |k, v| v }.to_h
-      if options[:size] == 1
-        store['references']['softbins'].first[0].to_i
-      else
-        reclaim(store['references']['softbins'], options)
-      end
-    end
 
-    def allocate_number(options)
-      bin = options[:bin]
-      softbin = options[:softbin]
-      return nil if config.numbers.empty?
-      if config.numbers.algorithm
-        algo = config.numbers.algorithm.to_s.downcase
-        if algo.to_s =~ /^[bs\dx]+$/
-          number = algo.to_s
-          bin = bin.to_s
-          if number =~ /(b+)/
-            max_bin_size = Regexp.last_match(1).size
-            if bin.size > max_bin_size
-              fail "Bin number (#{bin}) overflows the test number algorithm (#{algo})"
-            end
-            number = number.sub(/b+/, bin.rjust(max_bin_size, '0'))
-          end
-          softbin = softbin.to_s
-          if number =~ /(s+)/
-            max_softbin_size = Regexp.last_match(1).size
-            if softbin.size > max_softbin_size
-              fail "Softbin number (#{softbin}) overflows the test number algorithm (#{algo})"
-            end
-            number = number.sub(/s+/, softbin.rjust(max_softbin_size, '0'))
-          end
           if number =~ /(x+)/
             max_counter_size = Regexp.last_match(1).size
-            refs = store['references']['numbers']
+            refs = store['references'][type_plural]
             i = 0
             possible = []
-            proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0'))
+            proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0')).to_i.to_s
             possible << proposal
             while refs[proposal] && i.to_s.size <= max_counter_size
               i += 1
-              proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0'))
+              proposal = number.sub(/x+/, i.to_s.rjust(max_counter_size, '0')).to_i.to_s
               possible << proposal
             end
             # Overflowed, need to go search for the oldest duplicate now
@@ -604,39 +523,42 @@ module TestIds
             end
             number = proposal
           end
-          number.to_i
         else
-          fail "Unknown test number algorithm: #{algo}"
+          fail "Illegal algorithm: #{algo}"
         end
-      elsif callback = config.numbers.callback
-        callback.call(bin, softbin, options)
+        number.to_i
+      elsif callback = conf.callback
+        callback.call(options)
       else
-        if store['pointers']['numbers'] == 'done'
-          reclaim_number(options)
+        if store['pointers'][type_plural] == 'done'
+          reclaim_item(type, options)
         else
-          b = config.numbers.include.next(after: @last_number, size: options[:size])
-          @last_number = nil
-          while b && (store['manually_assigned']['numbers'][b.to_s] || config.numbers.exclude.include?(b))
-            b = config.numbers.include.next(size: options[:size])
+          b = conf.include.next(after: instance_variable_get("@last_#{type}"), size: options[:size])
+          instance_variable_set("@last_#{type}", nil)
+          while b && (store['manually_assigned'][type_plural][b.to_s] || conf.exclude.include?(b))
+            b = conf.include.next(size: options[:size])
           end
           # When no number is returned it means we have used them all, all future generation
           # now switches to reclaim mode
           if b
-            store['pointers']['numbers'] = b
+            store['pointers'][type_plural] = b + (options[:size] || 1) - 1
+            b
           else
-            store['pointers']['numbers'] = 'done'
-            reclaim_number(options)
+            store['pointers'][type_plural] = 'done'
+            reclaim_item(type, options)
           end
         end
       end
     end
 
-    def reclaim_number(options)
-      store['references']['numbers'] = store['references']['numbers'].sort_by { |k, v| v }.to_h
+    def reclaim_item(type, options)
+      type_plural = "#{type}s"
+      store['references'][type_plural] = store['references'][type_plural].sort_by { |k, v| v }.to_h
       if options[:size] == 1
-        store['references']['numbers'].first[0].to_i
+        v = store['references'][type_plural].first
+        v[0].to_i if v
       else
-        reclaim(store['references']['numbers'], options)
+        reclaim(store['references'][type_plural], options)
       end
     end
 

data/lib/test_ids/configuration.rb

@@ -1,22 +1,29 @@
 module TestIds
   class Configuration
     class Item
-      attr_accessor :include, :exclude, :algorithm, :size
+      attr_accessor :include, :exclude, :algorithm, :size, :needs
 
       def initialize
         @include = BinArray.new
         @exclude = BinArray.new
+        @needs = []
         @size = 1
       end
 
-      def callback(&block)
+      def callback(options = {}, &block)
         if block_given?
+          @needs += Array(options[:needs])
           @callback = block
         else
           @callback
         end
       end
 
+      def needs?(type)
+        !!(!empty? && function? && (needs.include?(type) ||
+            (algorithm && (algorithm.to_s =~ /#{type.to_s[0]}/i))))
+      end
+
       def empty?
         include.empty? && exclude.empty? && !algorithm && !callback
       end
@@ -36,6 +43,7 @@ module TestIds
       def freeze
         @include.freeze
         @exclude.freeze
+        @needs.freeze
         super
       end
 
@@ -88,18 +96,23 @@ module TestIds
       @id
     end
 
-    def bins(&block)
+    def bins(options = {}, &block)
       @bins ||= Item.new
       if block_given?
-        @bins.callback(&block)
+        @bins.callback(options, &block)
       end
       @bins
     end
 
-    def softbins(&block)
+    # An alias for config.bins.algorithm=
+    def bins=(val)
+      bins.algorithm = val
+    end
+
+    def softbins(options = {}, &block)
       @softbins ||= Item.new
       if block_given?
-        @softbins.callback(&block)
+        @softbins.callback(options, &block)
       end
       @softbins
     end
@@ -109,10 +122,10 @@ module TestIds
       softbins.algorithm = val
     end
 
-    def numbers(&block)
+    def numbers(options = {}, &block)
       @numbers ||= Item.new
       if block_given?
-        @numbers.callback(&block)
+        @numbers.callback(options, &block)
       end
       @numbers
     end
@@ -123,18 +136,23 @@ module TestIds
     end
 
     def send_to_ate=(val)
-      @send_to_ate = val
+      @send_to_ate = !!val
     end
 
-    def send_to_ate
-      @send_to_ate
+    def send_to_ate?
+      defined?(@send_to_ate) ? @send_to_ate : true
+    end
+
+    def unique_by_flow=(val)
+      @unique_by_flow = !!val
+    end
+
+    def unique_by_flow?
+      @unique_by_flow || false
     end
 
     def validate!
       unless validated?
-        if bins.algorithm
-          fail 'The TestIds bins configuration cannot be set to an algorithm, only a range set by bins.include and bins.exclude is permitted'
-        end
         @validated = true
         freeze
       end

data/lib/test_ids/origen_testers/flow.rb

@@ -7,13 +7,16 @@ module OrigenTesters
     # test numbers
     alias_method :_orig_test, :test
     def test(instance, options = {})
-      if TestIds.configured? && options[:test_ids] != :notrack
-        TestIds.current_configuration.allocator.allocate(instance, options)
-      end
       if TestIds.configured?
-        if TestIds.current_configuration.send_to_ate == false
-          BIN_OPTS.each do |opt|
-            options.delete(opt)
+        unless options[:test_ids] == :notrack
+          options[:test_ids_flow_id] = try(:top_level).try(:id) || id
+
+          TestIds.current_configuration.allocator.allocate(instance, options)
+
+          unless TestIds.current_configuration.send_to_ate?
+            BIN_OPTS.each do |opt|
+              options.delete(opt)
+            end
           end
         end
       end

data/lib/test_ids_dev/interface.rb

@@ -5,17 +5,23 @@ module TestIdsDev
     def initialize(options = {})
       case dut.test_ids
       when 1
-        TestIds.configure do |config|
+        TestIds.configure id: :cfg1 do |config|
           # Example of testing remote repo
           # config.repo = 'ssh://git@sw-stash.freescale.net/~r49409/test_ids_repo.git'
           config.bins.include << 3
           config.bins.include << (10..20)
           config.bins.exclude << 15
           config.softbins = :bbbxx
-          config.numbers do |bin, softbin|
-            softbin * 100
+          config.numbers needs: :softbin do |options|
+            options[:softbin] * 100
           end
         end
+
+      when 2
+        TestIds.configure id: :cfg2 do |config|
+          config.bins.include << (5..16)
+          config.softbins = :bbxxx
+        end
       end
     end
 

data/program/prb1.rb

@@ -1,7 +1,14 @@
 Flow.create do
-
-  func :t1
-  func :t2
-  func :t3
-  func :t3, bin: :none, sbin: :none
+  if dut.test_ids == 2
+    func :t1, bin: 11
+    func :t2, bin: 11
+    func :t3, bin: 11
+    func :t4, bin: 11
+    func :t5, bin: 11
+  else
+    func :t1
+    func :t2
+    func :t3
+    func :t3, bin: :none, sbin: :none
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_ids
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-16 00:00:00.000000000 Z
+date: 2020-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.40
+        version: 0.57.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.40
+        version: 0.57.0
 - !ruby/object:Gem::Dependency
   name: origen_testers
   requirement: !ruby/object:Gem::Requirement
@@ -100,8 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Origen plugin to assign and track test program bins and test numbers