origen 0.43.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50ff914ed84d58eef72d7c1eee3919a420d0a4af50bd9fe01fbf4c79f334578b
-  data.tar.gz: b51d183c27e9cb027f520a21f7bae2f8a21cd41d1158dfc8ec41feecb55409fd
+  metadata.gz: 9a8903e336caa8b0e7747f54f298178408b848f4203bfaccb4c7c2506c1df6c3
+  data.tar.gz: f3e398328927876c9ad9d7d46b04594f8ca7f33915be9b0d7956f0d86343c743
 SHA512:
-  metadata.gz: 8b227567f13516ee3cb2aeef1ea5b423febcfb3cfe2443f61a0e79857032cd301df77753cede06d88bd2ce2d1eea9720b48e60fb3b235946cf1121ede63f3f22
-  data.tar.gz: ef83425ec57f409158281bd045c9847dc5b97cbed7a89e99feb18a7037581309cfd7f7e3ae846e2b5626991f07cb310ade1cf4c2ce479337e38b80db576d6921
+  metadata.gz: fc638f7063bc0fa0ae993532d19360ed6d3191710d41d4cda3f31c72f86a165ac90854b4305335d49e64f67b2941bad5a456ebbf00e740238c8e1c3b6ef635e4
+  data.tar.gz: 8094048eb20dc9c3319fc5c5f629ba40a0c928915cf3c21ad3174119f2bad267fddcf9e4c2880d91abd1f3316bedaa963a60e6c2dec53a3c4bba3c52f681da8d

data/config/boot.rb

@@ -6,3 +6,5 @@ require "c99/ate_interface"
 require_relative "../lib/c99/nvm"
 
 require_relative "../helpers/guides"
+
+require "#{Origen.root(:origen_sim)}/config/boot"

data/config/version.rb

@@ -1,6 +1,6 @@
 module Origen
   MAJOR = 0
-  MINOR = 43
+  MINOR = 44
   BUGFIX = 0
   DEV = nil
 

data/lib/origen.rb

@@ -30,6 +30,8 @@ unless defined? RGen::ORIGENTRANSITION
   require 'origen/undefined'
   require 'origen/componentable'
 
+  autoload :PatSeq,              'origen/generator/pattern_sequencer'
+
   module Origen
     autoload :Features,          'origen/features'
     autoload :Bugs,              'origen/bugs'
@@ -75,17 +77,14 @@ unless defined? RGen::ORIGENTRANSITION
 
     APP_CONFIG = File.join('config', 'application.rb')
 
-    class OrigenError < StandardError
-      def self.status_code(code)
-        define_method(:status_code) { code }
-      end
-    end
-
-    class PerforceError < OrigenError;  status_code(11); end
-    class GitError < OrigenError; status_code(11); end
-    class DesignSyncError < OrigenError; status_code(12); end
-    class RevisionControlUninitializedError < OrigenError; status_code(13); end
-    class SyntaxError < OrigenError; status_code(14); end
+    class OrigenError < StandardError; end
+    class PerforceError < OrigenError; end
+    class GitError < OrigenError; end
+    class DesignSyncError < OrigenError; end
+    class RevisionControlUninitializedError < OrigenError; end
+    class SyntaxError < OrigenError; end
+    class BinStrValError < OrigenError; end
+    class HexStrValError < OrigenError; end
 
     class << self
       include Origen::Utility::TimeAndDate

data/lib/origen/application/runner.rb

@@ -84,23 +84,29 @@ module Origen
                   Origen.app.listeners_for(:program_generated).each(&:program_generated)
                 else
                   temporary_plugin_from_options = options[:current_plugin]
-                  expand_lists_and_directories(options[:files], options).each do |file|
-                    if temporary_plugin_from_options
-                      Origen.app.plugins.temporary = temporary_plugin_from_options
-                    end
-                    case options[:action]
-                    when :compile
-                      Origen.generator.compile_file_or_directory(file, options)
-                    when :merge
-                      Origen.generator.merge_file_or_directory(file, options)
-                    when :import_test_time
-                      Origen.time.import_test_time(file, options)
-                    when :import_test_flow
-                      Origen.time.import_test_flow(file, options)
-                    else
-                      Origen.generator.generate_pattern(file, options)
-                    end
+                  if options[:action] == :pattern && options[:sequence]
+                    patterns = expand_lists_and_directories(options[:files], options.merge(preserve_duplicates: true))
+                    Origen.generator.generate_pattern(patterns, options)
                     Origen.app.plugins.temporary = nil if temporary_plugin_from_options
+                  else
+                    expand_lists_and_directories(options[:files], options).each do |file|
+                      if temporary_plugin_from_options
+                        Origen.app.plugins.temporary = temporary_plugin_from_options
+                      end
+                      case options[:action]
+                      when :compile
+                        Origen.generator.compile_file_or_directory(file, options)
+                      when :merge
+                        Origen.generator.merge_file_or_directory(file, options)
+                      when :import_test_time
+                        Origen.time.import_test_time(file, options)
+                      when :import_test_flow
+                        Origen.time.import_test_flow(file, options)
+                      else
+                        Origen.generator.generate_pattern(file, options)
+                      end
+                      Origen.app.plugins.temporary = nil if temporary_plugin_from_options
+                    end
                   end
                 end
               end

data/lib/origen/commands/generate.rb

@@ -21,6 +21,7 @@ opt_parser = OptionParser.new do |opts|
   opts.on('--doc', 'Generate into doc format') { options[:doc] = true }
   opts.on('--html', 'Generate into html format') { options[:html] = true }
   opts.on('--nocom', 'No comments in the generated pattern') { options[:no_comments] = true }
+  opts.on('-seq', '--sequence NAME', String, 'Generate multiple patterns into a single concurrent pattern sequence') { |o| options[:sequence] = o }
   opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
   opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
   # Apply any application option extensions to the OptionParser

data/lib/origen/generator.rb

@@ -1,15 +1,18 @@
 module Origen
   class Generator
-    autoload :Pattern,         'origen/generator/pattern'
-    autoload :Flow,            'origen/generator/flow'
-    autoload :Resources,       'origen/generator/resources'
-    autoload :Job,             'origen/generator/job'
-    autoload :PatternFinder,   'origen/generator/pattern_finder'
-    autoload :PatternIterator, 'origen/generator/pattern_iterator'
-    autoload :Stage,           'origen/generator/stage'
-    autoload :Compiler,        'origen/generator/compiler'
-    autoload :Comparator,      'origen/generator/comparator'
-    autoload :Renderer,        'origen/generator/renderer'
+    autoload :Pattern,          'origen/generator/pattern'
+    autoload :Flow,             'origen/generator/flow'
+    autoload :Resources,        'origen/generator/resources'
+    autoload :Job,              'origen/generator/job'
+    autoload :PatternFinder,    'origen/generator/pattern_finder'
+    autoload :PatternIterator,  'origen/generator/pattern_iterator'
+    autoload :PatternSequencer, 'origen/generator/pattern_sequencer'
+    autoload :PatternSequence,  'origen/generator/pattern_sequence'
+    autoload :PatternThread,    'origen/generator/pattern_thread'
+    autoload :Stage,            'origen/generator/stage'
+    autoload :Compiler,         'origen/generator/compiler'
+    autoload :Comparator,       'origen/generator/comparator'
+    autoload :Renderer,         'origen/generator/renderer'
 
     class AbortError < StandardError; end
 
@@ -30,6 +33,10 @@ module Origen
     end
 
     def generate_pattern(file, options)
+      if options[:sequence]
+        options[:patterns] = file
+        file = options[:sequence]
+      end
       Job.new(file, options).run
     end
 

data/lib/origen/generator/job.rb

@@ -156,12 +156,36 @@ module Origen
               skip ||= !listener.before_pattern_lookup(@requested_pattern)
             end
             unless skip
-              @pattern = Origen.generator.pattern_finder.find(@requested_pattern, @options)
-              if @pattern.is_a?(Hash)
-                @output_file_body = @pattern[:output]
-                @pattern = @pattern[:pattern]
+              if @options[:sequence]
+                @pattern = @requested_pattern
+                Origen.pattern.sequence do |seq|
+                  # This splits the pattern name by "_" then removes all values that are common to all patterns
+                  # and then rejoins what is left.
+                  # The goal is to keep the thread ID concise for the log and rather than using the whole pattern
+                  # name only focussing on what is different.
+                  # e.g. if you combined patterns flash_read_ckbd_ip1_max.rb and flash_read_ckbd_ip2_max.rb into
+                  # a concurrent sequence then the two threads would be called 'ip1' and 'ip2'.
+                  ids = @options[:patterns].map do |pat|
+                    Pathname.new(pat).basename('.*').to_s.split('_')
+                  end
+                  ids = ids.map { |id| id.reject { |i| ids.all? { |id| id.include?(i) } }.join('_') }
+
+                  @options[:patterns].each_with_index do |pat, i|
+                    id = ids[i]
+                    id = i.to_s if id.empty?
+                    seq.in_parallel id do
+                      seq.run pat
+                    end
+                  end
+                end
+              else
+                @pattern = Origen.generator.pattern_finder.find(@requested_pattern, @options)
+                if @pattern.is_a?(Hash)
+                  @output_file_body = @pattern[:output]
+                  @pattern = @pattern[:pattern]
+                end
+                load @pattern unless @pattern == :skip  # Run the pattern
               end
-              load @pattern unless @pattern == :skip  # Run the pattern
             end
           end
         rescue Exception => e

data/lib/origen/generator/pattern.rb

@@ -59,96 +59,144 @@ module Origen
         pattern_close(options)
       end
 
-      def create(options = {})
+      def sequence(options = {}, &block)
         @create_options = options
         unless Origen.tester
           puts 'The current target has not instantiated a tester and pattern generation cannot run.'
-          puts 'Add something like this to your target file:'
-          puts ''
-          puts '  $tester = OrigenTesters::J750.new'
-          puts ''
+          puts 'Add something like this to an environment file:'
+          puts
+          puts '  Origen::Tester::J750.new'
+          puts
+          puts
+          puts 'Then select it by running:  origen e <environment name>'
           exit 1
         end
         Origen.tester.generating = :pattern
 
         job.output_file_body = options.delete(:name).to_s if options[:name]
 
-        # Order the iterators by the order that their enable keys appear in the options, pad
-        # any missing iterators with a dummy function...
-        iterators = options.map do |key, _val|
-          Origen.app.pattern_iterators.find { |iterator| iterator.key == key }
-        end.compact
-        iterators << DummyIterator.new while iterators.size < 10
-
-        args = []
-
-        # Couldn't get this to work fully dynamically, so hard-coded for 10 custom
-        # iterators for now, should be plenty for any application in the meantime.
-        # Should revisit this when time allows and remove this limitation by changing
-        # this to a recursive structure.
-        iterators[0].invoke(options) do |arg0|
-          args[0] = arg0
-          iterators[1].invoke(options) do |arg1|
-            args[1] = arg1
-            iterators[2].invoke(options) do |arg2|
-              args[2] = arg2
-              iterators[3].invoke(options) do |arg3|
-                args[3] = arg3
-                iterators[4].invoke(options) do |arg4|
-                  args[4] = arg4
-                  iterators[5].invoke(options) do |arg5|
-                    args[5] = arg5
-                    iterators[6].invoke(options) do |arg6|
-                      args[6] = arg6
-                      iterators[7].invoke(options) do |arg7|
-                        args[7] = arg7
-                        iterators[8].invoke(options) do |arg8|
-                          args[8] = arg8
-                          iterators[9].invoke(options) do |arg9|
-                            args[9] = arg9
-                            # Refresh the target to start all settings from scratch each time
-                            # This is an easy way to reset all registered values
-                            Origen.app.reload_target!(skip_first_time: true)
-
-                            # Final call back to the project to allow it to make any pattern name specific
-                            # configuration changes
-                            Origen.app.listeners_for(:before_pattern).each do |listener|
-                              listener.before_pattern(job.output_pattern_filename)
-                            end
+        # Refresh the target to start all settings from scratch each time
+        # This is an easy way to reset all registered values
+        Origen.app.reload_target!(skip_first_time: true)
 
-                            # Work out the final pattern name based on the current iteration
-                            job.reset_output_pattern_filename
-                            iterators.each_with_index do |iterator, i|
-                              if iterator.enabled?(options)
-                                job.output_pattern_filename =
-                                  iterator.pattern_name.call(job.output_pattern_filename, args[i])
-                              end
-                            end
+        # Final call back to the project to allow it to make any pattern name specific
+        # configuration changes
+        Origen.app.listeners_for(:before_pattern).each do |listener|
+          listener.before_pattern(job.output_pattern_filename)
+        end
 
-                            # Allow custom pattern prefix
-                            unless options[:pat_prefix].to_s.empty?
-                              if job.output_prefix.empty?
-                                job.output_pattern_filename = "#{options[:pat_prefix]}_" + job.output_pattern_filename
-                              else
-                                job.output_pattern_filename = job.output_pattern_filename.sub(job.output_prefix, job.output_prefix + "#{options[:pat_prefix]}_")
-                              end
-                            end
+        ## Allow custom pattern postfix
+        # unless options[:pat_postfix].to_s.empty?
+        #  job.output_pattern_filename = job.output_pattern_filename.sub(job.output_postfix + job.output_extension, "_#{options[:pat_postfix]}" + job.output_postfix + job.output_extension)
+        # end
+
+        @pattern_sequence = true
+        pattern_wrapper([], [], options) do
+          PatternSequencer.send(:active=, true)
+          @pattern_sequence = PatternSequence.new(job.output_pattern_filename, block)
+          @pattern_sequence.send(:execute)
+          PatternSequencer.send(:active=, false)
+        end
+        @pattern_sequence = false
+        @create_options = nil
+      end
 
-                            # Allow custom pattern postfix
-                            unless options[:pat_postfix].to_s.empty?
-                              job.output_pattern_filename = job.output_pattern_filename.sub(job.output_postfix + job.output_extension, "_#{options[:pat_postfix]}" + job.output_postfix + job.output_extension)
-                            end
+      def create(options = {})
+        if @pattern_sequence
+          yield
+        else
+          @create_options = options
+          unless Origen.tester
+            puts 'The current target has not instantiated a tester and pattern generation cannot run.'
+            puts 'Add something like this to an environment file:'
+            puts
+            puts '  Origen::Tester::J750.new'
+            puts
+            puts
+            puts 'Then select it by running:  origen e <environment name>'
+            exit 1
+          end
+          Origen.tester.generating = :pattern
+
+          job.output_file_body = options.delete(:name).to_s if options[:name]
 
-                            pattern_wrapper(iterators, args, options) do
-                              # Call iterator setups, whatever these return are passed to the pattern
-                              yield_items = []
+          # Order the iterators by the order that their enable keys appear in the options, pad
+          # any missing iterators with a dummy function...
+          iterators = options.map do |key, _val|
+            Origen.app.pattern_iterators.find { |iterator| iterator.key == key }
+          end.compact
+          iterators << DummyIterator.new while iterators.size < 10
+
+          args = []
+
+          # Couldn't get this to work fully dynamically, so hard-coded for 10 custom
+          # iterators for now, should be plenty for any application in the meantime.
+          # Should revisit this when time allows and remove this limitation by changing
+          # this to a recursive structure.
+          iterators[0].invoke(options) do |arg0|
+            args[0] = arg0
+            iterators[1].invoke(options) do |arg1|
+              args[1] = arg1
+              iterators[2].invoke(options) do |arg2|
+                args[2] = arg2
+                iterators[3].invoke(options) do |arg3|
+                  args[3] = arg3
+                  iterators[4].invoke(options) do |arg4|
+                    args[4] = arg4
+                    iterators[5].invoke(options) do |arg5|
+                      args[5] = arg5
+                      iterators[6].invoke(options) do |arg6|
+                        args[6] = arg6
+                        iterators[7].invoke(options) do |arg7|
+                          args[7] = arg7
+                          iterators[8].invoke(options) do |arg8|
+                            args[8] = arg8
+                            iterators[9].invoke(options) do |arg9|
+                              args[9] = arg9
+                              # Refresh the target to start all settings from scratch each time
+                              # This is an easy way to reset all registered values
+                              Origen.app.reload_target!(skip_first_time: true)
+
+                              # Final call back to the project to allow it to make any pattern name specific
+                              # configuration changes
+                              Origen.app.listeners_for(:before_pattern).each do |listener|
+                                listener.before_pattern(job.output_pattern_filename)
+                              end
+
+                              # Work out the final pattern name based on the current iteration
+                              job.reset_output_pattern_filename
                               iterators.each_with_index do |iterator, i|
                                 if iterator.enabled?(options)
-                                  yield_items << iterator.setup.call(args[i])
+                                  job.output_pattern_filename =
+                                    iterator.pattern_name.call(job.output_pattern_filename, args[i])
+                                end
+                              end
+
+                              # Allow custom pattern prefix
+                              unless options[:pat_prefix].to_s.empty?
+                                if job.output_prefix.empty?
+                                  job.output_pattern_filename = "#{options[:pat_prefix]}_" + job.output_pattern_filename
+                                else
+                                  job.output_pattern_filename = job.output_pattern_filename.sub(job.output_prefix, job.output_prefix + "#{options[:pat_prefix]}_")
                                 end
                               end
 
-                              yield(*yield_items)
+                              # Allow custom pattern postfix
+                              unless options[:pat_postfix].to_s.empty?
+                                job.output_pattern_filename = job.output_pattern_filename.sub(job.output_postfix + job.output_extension, "_#{options[:pat_postfix]}" + job.output_postfix + job.output_extension)
+                              end
+
+                              pattern_wrapper(iterators, args, options) do
+                                # Call iterator setups, whatever these return are passed to the pattern
+                                yield_items = []
+                                iterators.each_with_index do |iterator, i|
+                                  if iterator.enabled?(options)
+                                    yield_items << iterator.setup.call(args[i])
+                                  end
+                                end
+
+                                yield(*yield_items)
+                              end
                             end
                           end
                         end
@@ -473,6 +521,9 @@ module Origen
             log.info '----------------------------------------------------------------------'
             check_for_changes(job.output_pattern, job.reference_pattern) unless tester.try(:disable_pattern_diffs)
           end
+          if @pattern_sequence
+            @pattern_sequence.send(:log_execution_profile)
+          end
           stats.record_pattern_completion(job.output_pattern)
         end
 

data/lib/origen/generator/pattern_sequence.rb

@@ -0,0 +1,201 @@
+require 'io/console'
+
+module Origen
+  class Generator
+    # Manages a single pattern sequence, i.e. an instance of PatternSequence is
+    # created for every Pattern.sequence do ... end block
+    class PatternSequence
+      def initialize(name, block)
+        @number_of_threads = 1
+        @name = name
+        @running_thread_ids = { main: true }
+        # The contents of the main Pattern.sequence block will be executed as a thread and treated
+        # like any other parallel block
+        thread = PatternThread.new(:main, self, block, true)
+        threads << thread
+        active_threads << thread
+      end
+
+      # Execute the given pattern
+      def run(pattern_name)
+        pattern = Origen.generator.pattern_finder.find(pattern_name.to_s, {})
+        pattern = pattern[:pattern] if pattern.is_a?(Hash)
+        load pattern
+      end
+      alias_method :call, :run
+
+      # Execute the given block in a new concurrent thread
+      def thread(id = nil, &block)
+        @number_of_threads += 1
+        id ||= "thread#{@number_of_threads}".to_sym
+        # Just stage the request for now, it will be started at the end of the current execute loop
+        @parallel_blocks_waiting_to_start ||= []
+        @parallel_blocks_waiting_to_start << [id, block]
+        @running_thread_ids[id] = true
+      end
+      alias_method :in_parallel, :thread
+
+      def wait_for_threads(*ids)
+        completed = false
+        blocked = false
+        ids = ids.map(&:to_sym)
+        all = ids.empty? || ids.include?(:all)
+        until completed
+          if all
+            limit = current_thread.id == :main ? 1 : 2
+            if @running_thread_ids.size > limit
+              current_thread.waiting_for_thread(blocked)
+              blocked = true
+            else
+              current_thread.record_active if blocked
+              completed = true
+            end
+          else
+            if ids.any? { |id| @running_thread_ids[id] }
+              current_thread.waiting_for_thread(blocked)
+              blocked = true
+            else
+              current_thread.record_active if blocked
+              completed = true
+            end
+          end
+        end
+      end
+      alias_method :wait_for_thread, :wait_for_threads
+
+      private
+
+      def thread_running?(id)
+        @running_thread_ids[id]
+      end
+
+      def current_thread
+        PatSeq.thread
+      end
+
+      def log_execution_profile
+        if threads.size > 1
+          thread_id_size = threads.map { |t| t.id.to_s.size }.max
+          line_size = IO.console.winsize[1] - 35 - thread_id_size
+          line_size -= 16 if tester.try(:sim?)
+          cycles_per_tick = (@cycle_count_stop / (line_size * 1.0)).ceil
+          if tester.try(:sim?)
+            execution_time = tester.execution_time_in_ns / 1_000_000_000.0
+          else
+            execution_time = Origen.app.stats.execution_time_for(Origen.app.current_job.output_pattern)
+          end
+          Origen.log.info ''
+          tick_time = execution_time / line_size
+
+          Origen.log.info "Concurrent execution profile (#{pretty_time(tick_time)}/increment):"
+          Origen.log.info
+
+          number_of_ticks = @cycle_count_stop / cycles_per_tick
+
+          ticks_per_step = 0
+          step_size = 0.1.us
+
+          while ticks_per_step < 10
+            step_size = step_size * 10
+            ticks_per_step = step_size / tick_time
+          end
+
+          ticks_per_step = ticks_per_step.ceil
+          step_size = tick_time * ticks_per_step
+
+          if tester.try(:sim?)
+            padding = '.' + (' ' * (thread_id_size + 1))
+          else
+            padding = ' ' * (thread_id_size + 2)
+          end
+          scale_step = '|' + ('-' * (ticks_per_step - 1))
+          number_of_steps = (number_of_ticks / ticks_per_step) + 1
+          scale = scale_step * number_of_steps
+          scale = scale[0, number_of_ticks]
+          Origen.log.info padding + scale
+
+          scale = ''
+          number_of_steps.times do |i|
+            scale += pretty_time(i * step_size, 1).ljust(ticks_per_step)
+          end
+          scale = scale[0, number_of_ticks]
+          Origen.log.info padding + scale
+
+          threads.each do |thread|
+            line = thread.execution_profile(0, @cycle_count_stop, cycles_per_tick)
+            Origen.log.info ''
+            Origen.log.info "#{thread.id}: ".ljust(thread_id_size + 2) + line
+          end
+          Origen.log.info ''
+        end
+      end
+
+      def pretty_time(time, number_decimal_places = 0)
+        return '0' if time == 0
+        if time < 1.us
+          "%.#{number_decimal_places}fns" % (time * 1_000_000_000)
+        elsif time < 1.ms
+          "%.#{number_decimal_places}fus" % (time * 1_000_000)
+        elsif time < 1.s
+          "%.#{number_decimal_places}fms" % (time * 1_000)
+        else
+          "%.#{number_decimal_places}fs" % tick_time
+        end
+      end
+
+      def thread_completed(thread)
+        @running_thread_ids.delete(thread.id)
+        active_threads.delete(thread)
+      end
+
+      def threads
+        @threads ||= []
+      end
+
+      def active_threads
+        @active_threads ||= []
+      end
+
+      def threads_waiting_to_start?
+        @parallel_blocks_waiting_to_start
+      end
+
+      def execute
+        active_threads.first.start
+        until active_threads.empty?
+          # Advance all threads to their next cycle point in sequential order. Keeping tight control of
+          # when threads are running in this way ensures that the output is deterministic no matter what
+          # computer it is running on, and ensures that the application code does not have to worry about
+          # race conditions.
+          cycs = active_threads.map do |t|
+            t.advance
+            t.pending_cycles
+          end.compact.min
+
+          if cycs
+            # Now generate the required number of cycles which is defined by the thread that has the least
+            # amount of cycles ready to go.
+            # Since tester.cycle is being called by the master process here it will generate as normal (as
+            # opposed to when called from a thread in which case it causes the thread to wait).
+            cycs.cycles
+
+            # Now let each thread know how many cycles we just generated, so they can decide whether they
+            # need to wait for more cycles or if they can start preparing the next one
+            active_threads.each { |t| t.executed_cycles(cycs) }
+          end
+
+          if @parallel_blocks_waiting_to_start
+            @parallel_blocks_waiting_to_start.each do |id, block|
+              thread = PatternThread.new(id, self, block)
+              threads << thread
+              active_threads << thread
+              thread.start
+            end
+            @parallel_blocks_waiting_to_start = nil
+          end
+        end
+        @cycle_count_stop = threads.first.current_cycle_count
+      end
+    end
+  end
+end

data/lib/origen/generator/pattern_sequencer.rb

@@ -0,0 +1,99 @@
+require 'concurrent'
+module Origen
+  class Generator
+    # Provides APIs to enable applications to support concurrency
+    class PatternSequencer
+      class << self
+        def serialize(id = nil)
+          if active?
+            s = nil
+            id ||= caller[0]
+            @semaphores ||= {}
+            @semaphores[id] ||= Concurrent::Semaphore.new(1)
+            s = @semaphores[id]
+            completed = false
+            blocked = false
+            until completed
+              # If already acquired or available
+              if (thread.reservations[id] && thread.reservations[id][:semaphore]) || s.try_acquire
+                thread.record_active if blocked
+                yield
+                completed = true
+              else
+                thread.waiting_for_serialize(id, blocked)
+                blocked = true
+              end
+            end
+            # If the thread has reserved access to this serialized resource then don't release it now, but
+            # store a reference to the semaphore and it will be released at the end of the reserve block
+            if thread.reservations[id]
+              thread.reservations[id][:semaphore] = s
+            else
+              s.release
+            end
+          else
+            yield
+          end
+        end
+
+        # Once a lock is acquired on a serialize block with the given ID, it won't be released to
+        # other parallel threads until the end of this block
+        def reserve(id)
+          if active?
+            if thread.reservations[id]
+              thread.reservations[id][:count] += 1
+            else
+              thread.reservations[id] = { count: 1, semaphore: nil }
+            end
+            yield
+            if thread.reservations[id][:count] == 1
+              # May not be set if the application reserved the resource but never hit it
+              if s = thread.reservations[id][:semaphore]
+                s.release
+              end
+              thread.reservations[id] = nil
+            else
+              thread.reservations[id][:count] -= 1
+            end
+          else
+            yield
+          end
+        end
+
+        # Returns true if a pattern sequence is currently open/active
+        def active?
+          !!@active
+        end
+        alias_method :open?, :active?
+        alias_method :runnng?, :active?
+
+        # Returns the PatternThread object for the current thread
+        def thread
+          @thread.value
+        end
+
+        # Prepends the given string with "[<current thread ID>] " unless it already contains it
+        def add_thread(str)
+          if active? && thread
+            id = "[#{thread.id}] "
+            str.prepend(id) unless str =~ /#{id}/
+          end
+          str
+        end
+
+        private
+
+        def active=(val)
+          @active = val
+        end
+
+        def thread=(t)
+          @thread ||= Concurrent::ThreadLocalVar.new(nil)
+          @thread.value = t
+        end
+      end
+    end
+  end
+end
+PatSeq = Origen::Generator::PatternSequencer
+PatSeq.send(:thread=, nil)

data/lib/origen/generator/pattern_thread.rb

@@ -0,0 +1,175 @@
+module Origen
+  class Generator
+    # An instance of PatternThread is created for each parallel thread of execution
+    # in a pattern sequence. One instance of this class is also created to represent
+    # the original main thread in addition to those created by calling seq.in_parallel
+    class PatternThread
+      # Returns the parent pattern sequence object
+      attr_reader :sequence
+      attr_reader :pending_cycles
+      attr_reader :id
+      attr_reader :reservations
+      attr_reader :cycle_count_start
+      attr_reader :cycle_count_stop
+      # A record of when the thread is active to construct the execution profile
+      attr_reader :events
+
+      def initialize(id, sequence, block, primary = false)
+        if primary
+          @cycle_count_start = 0
+        else
+          @cycle_count_start = current_cycle_count
+        end
+        @events = [[:active, cycle_count_start]]
+        @id = id.to_sym
+        @sequence = sequence
+        @block = block
+        @primary = primary
+        @running = Concurrent::Event.new
+        @waiting = Concurrent::Event.new
+        @pending_cycles = nil
+        @completed = false
+        @reservations = {}
+      end
+
+      # Returns true if this is main thread (the one from which all in_parallel threads
+      # have been branched from)
+      def primary?
+        @primary
+      end
+
+      # @api private
+      #
+      # This method is called once by the pattern sequence to start a new thread. It will block until
+      # the thread is in the waiting state.
+      def start
+        @thread = Thread.new do
+          PatSeq.send(:thread=, self)
+          wait
+          @block.call(sequence)
+          sequence.send(:thread_completed, self)
+          record_cycle_count_stop
+          @completed = true
+          wait
+        end
+        @waiting.wait
+      end
+
+      def record_cycle_count_stop
+        @cycle_count_stop = current_cycle_count
+        events << [:stopped, cycle_count_stop]
+        events.freeze
+      end
+
+      def record_active
+        events << [:active, current_cycle_count]
+      end
+
+      def current_cycle_count
+        tester.try(:cycle_count) || 0
+      end
+
+      def execution_profile(start, stop, step)
+        events = @events.dup
+        cycles = start
+        state = :inactive
+        line = ''
+        ((stop - start) / step).times do |i|
+          active_cycles = 0
+          while events.first && events.first[1] >= cycles && events.first[1] < cycles + step
+            event = events.shift
+            # Bring the current cycles up to this event point applying the current state
+            if state == :active
+              active_cycles += event[1] - cycles
+            end
+            state = event[0] == :active ? :active : :inactive
+            cycles = event[1]
+          end
+
+          # Bring the current cycles up to the end of this profile tick
+          if state == :active
+            active_cycles += ((i + 1) * step) - cycles
+          end
+          cycles = ((i + 1) * step)
+
+          if active_cycles == 0
+            line += '_'
+          elsif active_cycles > (step * 0.5)
+            line += '█'
+          else
+            line += '▄'
+          end
+        end
+        line
+      end
+
+      # Will be called when the thread can't execute its next cycle because it is waiting to obtain a
+      # lock on a serialized block
+      def waiting_for_serialize(serialize_id, skip_event = false)
+        # puts "Thread #{id} is blocked waiting for #{serialize_id}"
+        events << [:waiting, current_cycle_count] unless skip_event
+        wait
+      end
+
+      # Will be called when the thread can't execute its next cycle because it is waiting for another
+      # thread to complete
+      def waiting_for_thread(skip_event = false)
+        events << [:waiting, current_cycle_count] unless skip_event
+        wait
+      end
+
+      # Will be called when the thread is ready for the next cycle
+      def cycle(options)
+        @pending_cycles = options[:repeat] || 1
+        # If there are threads pending start and we are about to enter a long delay, block for only
+        # one cycle to give them a change to get underway and make use of this delay
+        if @pending_cycles > 1 && sequence.send(:threads_waiting_to_start?)
+          remainder = @pending_cycles - 1
+          @pending_cycles = 1
+        end
+        wait
+        @pending_cycles = remainder if remainder
+        # If the sequence did not do enough cycles in that round to satisfy this thread, then go back
+        # around to complete the remainder before continuing with the rest of the pattern
+        if @pending_cycles == 0
+          @pending_cycles = nil
+        elsif @pending_cycles > 0
+          @pending_cycles.cycles
+        else
+          fail "Something has gone wrong @pending_cycles is #{@pending_cycles}"
+        end
+      end
+
+      # @api private
+      def executed_cycles(cycles)
+        @pending_cycles -= cycles if @pending_cycles
+      end
+
+      def completed?
+        @completed
+      end
+
+      # Returns true if the thread is currently waiting for the pattern sequence to advance it
+      def waiting?
+        @waiting.set?
+      end
+
+      # This should be called only by the pattern thread itself, and will block it until it is told to
+      # advance by the pattern sequence running in the main thread
+      def wait
+        @running.reset
+        @waiting.set
+        @running.wait
+      end
+
+      # This should be called only by the pattern sequence running in the main thread, it will un-block the
+      # pattern thread which is currently waiting, and it will block the main thread until the pattern thread
+      # reaches the next wait point (or completes)
+      def advance(completed_cycles = nil)
+        @waiting.reset
+        @running.set         # Release the pattern thread
+        @waiting.wait        # And wait for it to reach the next wait point
+      end
+    end
+  end
+end

data/lib/origen/log.rb

@@ -107,6 +107,7 @@ module Origen
 
     def debug(string = '', options = {})
       string, options = sanitize_args(string, options)
+      PatSeq.add_thread(string) unless options[:no_thread_id]
       intercept(string, :debug, options) do |msg, type, options|
         msg = format_msg('DEBUG', msg)
         log_files(:debug, msg) unless console_only?(options)
@@ -117,6 +118,7 @@ module Origen
 
     def info(string = '', options = {})
       string, options = sanitize_args(string, options)
+      PatSeq.add_thread(string) unless options[:no_thread_id]
       intercept(string, :info, options) do |msg, type, options|
         msg = format_msg('INFO', msg)
         log_files(:info, msg) unless console_only?(options)
@@ -130,6 +132,7 @@ module Origen
 
     def success(string = '', options = {})
       string, options = sanitize_args(string, options)
+      PatSeq.add_thread(string) unless options[:no_thread_id]
       intercept(string, :success, options) do |msg, type, options|
         msg = format_msg('SUCCESS', msg)
         log_files(:info, msg) unless console_only?(options)
@@ -140,6 +143,7 @@ module Origen
 
     def deprecate(string = '', options = {})
       string, options = sanitize_args(string, options)
+      PatSeq.add_thread(string) unless options[:no_thread_id]
       intercept(string, :deprecate, options) do |msg, type, options|
         msg = format_msg('DEPRECATED', msg)
         log_files(:warn, msg) unless console_only?(options)
@@ -151,6 +155,7 @@ module Origen
 
     def warn(string = '', options = {})
       string, options = sanitize_args(string, options)
+      PatSeq.add_thread(string) unless options[:no_thread_id]
       intercept(string, :warn, options) do |msg, type, options|
         msg = format_msg('WARNING', msg)
         log_files(:warn, msg) unless console_only?(options)
@@ -162,6 +167,7 @@ module Origen
 
     def error(string = '', options = {})
       string, options = sanitize_args(string, options)
+      PatSeq.add_thread(string) unless options[:no_thread_id]
       intercept(string, :error, options) do |msg, type, options|
         msg = format_msg('ERROR', msg)
         log_files(:error, msg) unless console_only?(options)

data/lib/origen/registers/bit.rb

@@ -97,6 +97,8 @@ module Origen
       # Returns the basic access string for a given access method.  Possible values: read-write, read-only,
       # write-only, writeOnce, read-writeOnce.  Used primarily by CrossOrigen IP-XACT import/export.
       attr_reader :base_access
+      # Can be set to indicate that the current state of the bit is unknown, e.g. after reading X from a simulation
+      attr_accessor :unknown
 
       def initialize(owner, position, options = {}) # rubocop:disable MethodLength
         options = {
@@ -290,7 +292,7 @@ module Origen
       # unknown in cases where the reset value is undefined or determined by a memory location
       # and where the bit has not been written or read to a specific value yet.
       def has_known_value?
-        !@reset_val.is_a?(Symbol) || @updated_post_reset
+        !@unknown && (!@reset_val.is_a?(Symbol) || @updated_post_reset)
       end
 
       # Set the data value of the bit to the given value (1 or 0)

data/lib/origen/registers/bit_collection.rb

@@ -15,6 +15,7 @@ module Origen
       DONT_CARE_CHAR = 'X'
       OVERLAY_CHAR = 'V'
       STORE_CHAR = 'S'
+      UNKNOWN_CHAR = '?'
 
       attr_accessor :name
       alias_method :id, :name
@@ -389,6 +390,11 @@ module Origen
       alias_method :value=, :write
       alias_method :val=, :write
 
+      # Sets the unknown attribute on all contained bits
+      def unknown=(val)
+        each { |bit| bit.unknown = val }
+      end
+
       # Will tag all bits for read and if a data value is supplied it
       # will update the expected data for when the read is performed.
       def read(value = nil, options = {}) # :nodoc:
@@ -902,7 +908,11 @@ module Origen
               if bit.has_overlay? && options[:mark_overlays]
                 str += OVERLAY_CHAR
               else
-                str += bit.data.to_s
+                if bit.has_known_value?
+                  str += bit.data.to_s
+                else
+                  str += UNKNOWN_CHAR
+                end
               end
             else
               str += DONT_CARE_CHAR
@@ -913,7 +923,11 @@ module Origen
             if bit.has_overlay? && options[:mark_overlays]
               str += OVERLAY_CHAR
             else
-              str += bit.data.to_s
+              if bit.has_known_value?
+                str += bit.data.to_s
+              else
+                str += UNKNOWN_CHAR
+              end
             end
           end
         else
@@ -987,7 +1001,7 @@ module Origen
 
         nibbles.each_with_index do |nibble, i|
           # If contains any special chars...
-          if nibble =~ /[#{DONT_CARE_CHAR}#{STORE_CHAR}#{OVERLAY_CHAR}]/
+          if nibble =~ /[#{UNKNOWN_CHAR}#{DONT_CARE_CHAR}#{STORE_CHAR}#{OVERLAY_CHAR}]/
             # If all the same...
             if nibble[0] == nibble[1] && nibble[1] == nibble[2] && nibble[2] == nibble[3]
               outstr += nibble[0, 1] # .to_s

data/lib/origen/value/bin_str_val.rb

@@ -64,7 +64,7 @@ module Origen
         if val =~ /^[01_xXzZ]+$/
           true
         else
-          fail Origen::SyntaxError, 'Binary string values can only contain: 0, 1, _, x, X, z, Z'
+          fail Origen::BinStrValError, "Binary string values can only contain: 0, 1, _, x, X, z, Z, this is invalid: #{val}"
         end
       end
     end

data/lib/origen/value/hex_str_val.rb

@@ -92,7 +92,7 @@ module Origen
         if val =~ /^[0-9a-fA-F_xXzZ]+$/
           true
         else
-          fail Origen::SyntaxError, 'Hex string values can only contain: 0-9, a-f, A-F, _, x, X, z, Z'
+          fail Origen::HexStrValError, "Hex string values can only contain: 0-9, a-f, A-F, _, x, X, z, Z, this is invalid: #{val}"
         end
       end
     end

data/origen_app_generators/origen_app_generators.gemspec

@@ -8,16 +8,16 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 1.8.11".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Stephen McGinty".freeze]
-  s.date = "2018-12-19"
+  s.date = "2019-05-16"
   s.email = ["stephen.f.mcginty@gmail.com".freeze]
   s.files = ["bin/boot.rb".freeze, "bin/fix_my_workspace".freeze, "config/application.rb".freeze, "config/boot.rb".freeze, "config/commands.rb".freeze, "config/shared_commands.rb".freeze, "config/version.rb".freeze, "lib/origen_app_generators.rb".freeze, "lib/origen_app_generators/application.rb".freeze, "lib/origen_app_generators/base.rb".freeze, "lib/origen_app_generators/empty_application.rb".freeze, "lib/origen_app_generators/empty_plugin.rb".freeze, "lib/origen_app_generators/new.rb".freeze, "lib/origen_app_generators/origen_infrastructure/app_generator_plugin.rb".freeze, "lib/origen_app_generators/plugin.rb".freeze, "lib/origen_app_generators/sub_block_parser.rb".freeze, "lib/origen_app_generators/test_engineering/stand_alone_application.rb".freeze, "lib/origen_app_generators/test_engineering/test_block.rb".freeze, "lib/tasks/app_generators.rake".freeze, "lib/tasks/new_app_tests.rake".freeze, "templates/app_generators".freeze, "templates/app_generators/application".freeze, "templates/app_generators/application/.gitignore".freeze, "templates/app_generators/application/.irbrc".freeze, "templates/app_generators/application/.rspec".freeze, "templates/app_generators/application/.travis.yml".freeze, "templates/app_generators/application/Gemfile".freeze, "templates/app_generators/application/Rakefile".freeze, "templates/app_generators/application/config".freeze, "templates/app_generators/application/config/application.rb".freeze, "templates/app_generators/application/config/boot.rb".freeze, "templates/app_generators/application/config/commands.rb".freeze, "templates/app_generators/application/config/maillist_dev.txt".freeze, "templates/app_generators/application/config/maillist_prod.txt".freeze, "templates/app_generators/application/config/version.rb".freeze, "templates/app_generators/application/doc".freeze, "templates/app_generators/application/doc/history".freeze, "templates/app_generators/application/dot_keep".freeze, "templates/app_generators/application/lib".freeze, "templates/app_generators/application/lib/app.rake".freeze, "templates/app_generators/application/lib/module.rb".freeze, "templates/app_generators/application/lib/top_level.rb".freeze, "templates/app_generators/application/origen_core_session".freeze, "templates/app_generators/application/spec".freeze, "templates/app_generators/application/spec/spec_helper.rb".freeze, "templates/app_generators/application/target".freeze, "templates/app_generators/application/target/debug.rb".freeze, "templates/app_generators/application/target/default.rb".freeze, "templates/app_generators/application/target/production.rb".freeze, "templates/app_generators/application/templates".freeze, "templates/app_generators/application/templates/web".freeze, "templates/app_generators/application/templates/web/index.md.erb".freeze, "templates/app_generators/application/templates/web/layouts".freeze, "templates/app_generators/application/templates/web/layouts/_basic.html.erb".freeze, "templates/app_generators/application/templates/web/partials".freeze, "templates/app_generators/application/templates/web/partials/_navbar.html.erb".freeze, "templates/app_generators/application/templates/web/release_notes.md.erb".freeze, "templates/app_generators/new".freeze, "templates/app_generators/new/generator.rb".freeze, "templates/app_generators/new/info.md.erb".freeze, "templates/app_generators/origen_infrastructure".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/config".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/config/load_generators.rb".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/lib".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/lib/application.rb".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/lib/base.rb".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/lib/module.rb".freeze, "templates/app_generators/origen_infrastructure/app_generator_plugin/lib/plugin.rb".freeze, "templates/app_generators/plugin".freeze, "templates/app_generators/plugin/Gemfile".freeze, "templates/app_generators/plugin/Rakefile".freeze, "templates/app_generators/plugin/config".freeze, "templates/app_generators/plugin/config/boot.rb".freeze, "templates/app_generators/plugin/gemspec.rb".freeze, "templates/app_generators/plugin/lib".freeze, "templates/app_generators/plugin/lib/README".freeze, "templates/app_generators/plugin/lib_dev".freeze, "templates/app_generators/plugin/lib_dev/README".freeze, "templates/app_generators/plugin/templates".freeze, "templates/app_generators/plugin/templates/web".freeze, "templates/app_generators/plugin/templates/web/index.md.erb".freeze, "templates/app_generators/plugin/templates/web/partials".freeze, "templates/app_generators/plugin/templates/web/partials/_navbar_external.html.erb".freeze, "templates/app_generators/plugin/templates/web/partials/_navbar_internal.html.erb".freeze, "templates/app_generators/test_engineering".freeze, "templates/app_generators/test_engineering/stand_alone_application".freeze, "templates/app_generators/test_engineering/stand_alone_application/Gemfile".freeze, "templates/app_generators/test_engineering/stand_alone_application/environment".freeze, "templates/app_generators/test_engineering/stand_alone_application/environment/j750.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/environment/jlink.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/environment/uflex.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/environment/v93k.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/lib".freeze, "templates/app_generators/test_engineering/stand_alone_application/lib/ip_block.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/lib/ip_block_controller.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/lib/top_level.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/lib/top_level_controller.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/pattern".freeze, "templates/app_generators/test_engineering/stand_alone_application/pattern/example.rb".freeze, "templates/app_generators/test_engineering/stand_alone_application/target".freeze, "templates/app_generators/test_engineering/stand_alone_application/target/top_level.rb".freeze, "templates/app_generators/test_engineering/test_block".freeze, "templates/app_generators/test_engineering/test_block/environment".freeze, "templates/app_generators/test_engineering/test_block/environment/j750.rb".freeze, "templates/app_generators/test_engineering/test_block/environment/ultraflex.rb".freeze, "templates/app_generators/test_engineering/test_block/environment/v93k.rb".freeze, "templates/app_generators/test_engineering/test_block/lib".freeze, "templates/app_generators/test_engineering/test_block/lib/controller.rb".freeze, "templates/app_generators/test_engineering/test_block/lib/interface.rb".freeze, "templates/app_generators/test_engineering/test_block/lib/model.rb".freeze, "templates/app_generators/test_engineering/test_block/lib_dev".freeze, "templates/app_generators/test_engineering/test_block/lib_dev/dut.rb".freeze, "templates/app_generators/test_engineering/test_block/lib_dev/dut_controller.rb".freeze, "templates/app_generators/test_engineering/test_block/pattern".freeze, "templates/app_generators/test_engineering/test_block/pattern/example.rb".freeze, "templates/app_generators/test_engineering/test_block/program".freeze, "templates/app_generators/test_engineering/test_block/program/prb1.rb".freeze, "templates/app_generators/test_engineering/test_block/target".freeze, "templates/app_generators/test_engineering/test_block/target/default.rb".freeze]
   s.homepage = "http://origen-sdk.org/origen_app_generators".freeze
   s.licenses = ["MIT".freeze]
   s.required_ruby_version = Gem::Requirement.new(">= 1.9.3".freeze)
-  s.rubygems_version = "2.7.7".freeze
+  s.rubygems_version = "2.7.6".freeze
   s.summary = "Origen application generators".freeze
 
-  s.installed_by_version = "2.7.7" if s.respond_to? :installed_by_version
+  s.installed_by_version = "2.7.6" if s.respond_to? :installed_by_version
 
   if s.respond_to? :specification_version then
     s.specification_version = 4

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.43.0
+  version: 0.44.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-08 00:00:00.000000000 Z
+date: 2019-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -374,6 +374,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - stephen.f.mcginty@gmail.com
@@ -502,6 +516,9 @@ files:
 - lib/origen/generator/pattern.rb
 - lib/origen/generator/pattern_finder.rb
 - lib/origen/generator/pattern_iterator.rb
+- lib/origen/generator/pattern_sequence.rb
+- lib/origen/generator/pattern_sequencer.rb
+- lib/origen/generator/pattern_thread.rb
 - lib/origen/generator/renderer.rb
 - lib/origen/generator/resources.rb
 - lib/origen/generator/stage.rb
@@ -752,7 +769,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: The Semiconductor Developer's Kit