origen 0.34.3 → 0.52.0

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/loader.rb

@@ -0,0 +1,381 @@
+module Origen
+  # This module is responsible for enhancing how Ruby requires and loads files to support loading of
+  # classes and modules from an application's app dir without having to require them.
+  #
+  # It also implements the <model>.load_block method that loads files from app/blocks.
+  module Loader
+    # @api private
+    #
+    # Unload all constants (classes and modules) that have been auto-loaded since this was last called
+    def self.unload
+      # puts "******** LOADED CONSTS@ #{@loaded_consts}"
+      path = []
+      (@consts_hierarchy || {}).each do |name, children|
+        _unload(path, name, children)
+      end
+      @consts_hierarchy = {}
+      @loaded_consts = {}
+      (Origen.app.plugins + [Origen.app]).each do |app|
+        app.instance_variable_set(:@blocks_files, nil)
+      end
+      nil
+    end
+
+    # @api private
+    def self._unload(path, name, children)
+      path << name
+      children.each do |name, children|
+        _unload(path, name, children)
+      end
+      const = path.join('::')
+      if @loaded_consts[const]
+        path[0...-1].join('::').constantize.send :remove_const, path.last
+        # puts "******** Unloading: #{const}"
+      end
+      path.pop
+    end
+
+    # @api private
+    def self.record_const(name)
+      @consts_hierarchy ||= {}
+      @loaded_consts ||= {}
+      @loaded_consts[name] = true
+      pointer = nil
+      name.split('::').each do |name|
+        if pointer
+          pointer[name] ||= {}
+          pointer = pointer[name]
+        else
+          @consts_hierarchy[name] ||= {}
+          pointer = @consts_hierarchy[name]
+        end
+      end
+    end
+
+    # @api private
+    def self.load_attributes(file, model)
+      if model.respond_to?(:is_an_origen_model?)
+        attributes = model.attributes.dup
+      else
+        attributes = {}
+      end
+      vars = model.instance_variables
+      if load_block_file(file, model)
+        # Update the value of any pre-existing attribute that could have just changed
+        attributes.each do |a, v|
+          attributes[a] = model.instance_variable_get("@#{a}")
+        end
+        # And add any new ones that were encountered for the first time
+        (model.instance_variables - vars).each do |var|
+          val = model.instance_variable_get(var)
+          attribute = var.to_s.sub('@', '')
+          attributes[attribute.to_sym] = val
+          unless model.respond_to?(attribute)
+            model.define_singleton_method(attribute) do
+              instance_variable_get(var)
+            end
+          end
+          if val == true || val == false
+            attribute += '?'
+            unless model.respond_to?(attribute)
+              model.define_singleton_method(attribute) do
+                instance_variable_get(var)
+              end
+            end
+          end
+        end
+        if model.respond_to?(:is_an_origen_model?)
+          attributes.freeze
+          model.instance_variable_set(:@attributes, attributes)
+        end
+        true
+      end
+    end
+
+    # @api private
+    def self.load_block_file(file, model)
+      file = file.to_s
+      if File.exist?(file)
+        File.open(file, 'r') do |f|
+          model.instance_eval(f.read, file)
+        end
+      end
+      true
+    end
+
+    # @api private
+    def self.with_parameters_transaction(type)
+      if type == :parameters
+        Origen::Parameters.transaction do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    # If a block definition exists for the given model, then this will load it and apply it to
+    # the model.
+    # Returns true if a model is found and loaded, otherwise nil.
+    def self.load_block(model, options = {})
+      model = model.model  # Ensure we have a handle on the model and not its controller
+      loaded = nil
+      if app = options[:app] || model.app
+        if options[:path]
+          full_paths = Array(options[:path])
+        else
+          full_paths = model.class.to_s.split('::')
+          full_paths.shift  # Throw away the app namespace
+          full_paths = [full_paths.join('/')]
+        end
+        full_paths.each do |full_path|
+          paths = full_path.to_s.split('/')
+          key = ''
+          only = Array(options[:only]) if options[:only]
+          except = Array(options[:except]) if options[:except]
+          path = paths.map(&:underscore).join('/')
+          # If the path refers to a nested sub-block then don't load the full hierarchy since they
+          # don't support inheritance or derivatives, modify the paths array so that only the sub-block
+          # level will be loaded and nothing else.
+          paths = [path] if app.blocks_files[path] && app.blocks_files[path][:_sub_block]
+          # These will be loaded first, followed by the rest in an undefined order.
+          # Attributes and parameters are first so that they may be referenced in the other files.
+          # Sub-blocks was added early due to a corner case issue that could be encountered if the pins or
+          # regs imported an Origen exported file that defined a module with the same name as a sub-block
+          # class, in that case the sub-block class would not be auto-loaded.
+          load_first = [:attributes, :parameters, :sub_blocks]
+
+          load_first.each do |type|
+            unless (only && !only.include?(type)) || (except && except.include?(type))
+              with_parameters_transaction(type) do
+                paths.each_with_index do |path, i|
+                  key = i == 0 ? path.underscore : "#{key}/#{path.underscore}"
+                  if app.blocks_files[key] && app.blocks_files[key][type]
+                    app.blocks_files[key][type].each do |f|
+                      if type == :attributes
+                        success = load_attributes(f, model)
+                      else
+                        success = load_block_file(f, model)
+                      end
+                      loaded ||= success
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Now load the rest
+          paths.each_with_index do |path, i|
+            key = i == 0 ? path.underscore : "#{key}/#{path.underscore}"
+            if app.blocks_files[key]
+              app.blocks_files[key].each do |type, files|
+                unless type == :_sub_block || load_first.include?(type) || (only && !only.include?(type)) || (except && except.include?(type))
+                  files.each { |f| success = load_block_file(f, model); loaded ||= success }
+                end
+              end
+            end
+          end
+        end
+      end
+      loaded
+    end
+
+    # This is inspired by Rails' ActiveSupport::Dependencies module.
+    module ModuleConstMissing
+      def self.append_features(base)
+        base.class_eval do
+          # Emulate #exclude via an ivar
+          return if defined?(@_const_missing) && @_const_missing
+          @_const_missing = instance_method(:const_missing)
+          remove_method(:const_missing)
+        end
+        super
+      end
+
+      def self.exclude_from(base)
+        base.class_eval do
+          define_method :const_missing, @_const_missing
+          @_const_missing = nil
+        end
+      end
+
+      # @api private
+      # Substitutes a single occurrence of 'derivatives' in the given dirs array, starting
+      # from the end of it and replacing it with the given new value.
+      # Returns true if a substitution is made, else false.
+      def _sub_derivatives_from_end(new_val, dirs)
+        subbed = false
+        size = dirs.size - 1
+        dirs.reverse_each.with_index do |val, i|
+          if val == 'derivatives'
+            dirs[size - i] = new_val
+            subbed = true
+            break
+          end
+        end
+        dirs if subbed
+      end
+
+      # Allows classes and modules to be defined in app/blocks and app/lib without needing to
+      # require them and in the case of app/blocks to use a custom directory structure.
+      #
+      # The first time a reference is made to a class or module name it will trigger this hook,
+      # and we then work out what the file name should be and require it.
+      def const_missing(name)
+        if Origen.in_app_workspace?
+          if self == Object
+            name = name.to_s
+          else
+            name = "#{self}::#{name}"
+          end
+          return nil if @_checking_name == name
+          names = name.split('::')
+          namespace = names.shift
+          if app = Origen::Application.from_namespace(namespace)
+            # First we are going to check for a match in the app/blocks directory, this needs to be handled
+            # specially since it follows a non-std structure, e.g. use of derivatives/ and sub_blocks/ folders
+            # for organization without having them as part of the class name-spacing
+            altname = nil
+            dirs = [app.root, 'app', 'blocks']
+            names.each_with_index do |name, i|
+              dirs << 'derivatives' unless i == 0
+              dirs << name.underscore
+            end
+
+            # Is this a reference to a model?
+            if File.exist?(f = File.join(*dirs, 'model.rb'))
+              model = _load_const(f, name)
+              # Also load the model's controller if it exists
+              if File.exist?(f = File.join(*dirs, 'controller.rb'))
+                controller = _load_const(f, name + 'Controller')
+              end
+              return model
+            end
+
+            # Is this a reference to a controller?
+            if dirs.last.to_s =~ /_controller$/
+              controller_reference = true
+              dirs << dirs.pop.sub(/_controller$/, '')
+              if File.exist?(f = File.join(*dirs, 'controller.rb'))
+                return _load_const(f, name)
+              end
+            end
+
+            # Is this a reference to a sub-block model or controller that is nested within a block?
+            dirs_ = dirs.dup
+            while dirs_ = _sub_derivatives_from_end('sub_blocks', dirs_)
+              if controller_reference
+                if File.exist?(f = File.join(*dirs_, 'controller.rb'))
+                  return _load_const(f, name)
+                end
+              elsif File.exist?(f = File.join(*dirs_, 'model.rb'))
+                model = _load_const(f, name)
+                # Also load the model's controller if it exists
+                if File.exist?(f = File.join(*dirs_, 'controller.rb'))
+                  controller = _load_const(f, name + 'Controller')
+                end
+                return model
+              end
+            end
+
+            # Is this a reference to a module that has been added to a model or controller?
+            # In this case dirs contains something like:
+            #    [..., "my_model", "derivatives", "my_module"]
+            #    [..., "my_model_controller", "derivatives", "my_module"]
+            # So let's try by transforming these into:
+            #    [..., "my_model", "model"] + "my_module.rb"
+            #    [..., "my_model", "controller"] + "my_module.rb"
+            filename = dirs.pop + '.rb'
+            dirs.pop # Lose 'derivatives'
+            if dirs.last.to_s =~ /_controller$/
+              dirs << dirs.pop.sub(/_controller$/, '')
+              dirs << 'controller'
+            else
+              dirs << 'model'
+            end
+            if File.exist?(f = File.join(*dirs, filename))
+              return _load_const(f, name)
+            end
+
+            # Now that we have established that it is not a reference to a block (which has a non-std code
+            # organization structure), we can now check for a match in the app/lib directory following std
+            # Ruby code organization conventions
+            until names.empty?
+              path = File.join(*names.map(&:underscore)) + '.rb'
+
+              f = File.join(app.root, 'app', 'lib', namespace.underscore, path)
+              if File.exist?(f)
+                model = _load_const(f, name, altname)
+                # Try and reference the controller to load it too, though don't raise an error if it
+                # doesn't exist
+                @@pre_loading_controller = true
+                eval "#{altname || name}Controller"
+                return model
+              # If a folder exists that is named after this constant, then assume it is an otherwise
+              # undeclared namespace module and declare it now
+              elsif File.exist?(f.sub('.rb', ''))
+                return const_set path.sub('.rb', '').camelcase, Module.new
+              end
+
+              # Don't waste time looking up the namespace hierarchy for the controller, if it exists it
+              # should be within the exact same namespace as the model
+              return nil if defined?(@@pre_loading_controller) && @@pre_loading_controller
+
+              # Remove the highest level namespace and then search again in the parent namespace
+              if discarded_namespace = names.delete_at(-2)
+                altname ||= name
+                altname = altname.sub("#{discarded_namespace}::", '')
+              else
+                names.pop
+              end
+            end
+
+            _raise_uninitialized_constant_error(name)
+          else
+            _raise_uninitialized_constant_error(name)
+          end
+        else
+          _raise_uninitialized_constant_error(name)
+        end
+      ensure
+        @@pre_loading_controller = false
+      end
+
+      # @api_private
+      def _load_const(file, name, altname = nil)
+        load file
+        if defined?(@@pre_loading_controller)
+          return if @@pre_loading_controller
+        end
+        @_checking_name = altname || name
+        const = eval(altname || name)
+        @_checking_name = nil
+        if const
+          Origen::Loader.record_const(altname || name)
+          return const
+        end
+        msg ||= "uninitialized constant #{name} (expected it to be defined in: #{file})"
+        _raise_uninitialized_constant_error(name, msg)
+      end
+
+      # @api private
+      def _raise_uninitialized_constant_error(name, msg = nil)
+        msg ||= "uninitialized constant #{name}"
+        name_error = NameError.new(msg, name)
+        name_error.set_backtrace(caller.reject { |l| l =~ /^#{__FILE__}/ })
+        fail name_error
+      end
+    end
+
+    def self.enable_origen_load_extensions!
+      Module.class_eval { include ModuleConstMissing }
+    end
+
+    def self.disable_origen_load_extensions!
+      ModuleConstMissing.exclude_from(Module)
+    end
+  end
+end
+
+Origen::Loader.enable_origen_load_extensions!