origen 0.28.2 → 0.29.0

data/lib/origen/core_ext.rb

@@ -1,7 +1,6 @@
 require 'origen/core_ext/object'
 require 'origen/core_ext/string'
-require 'origen/core_ext/fixnum'
-require 'origen/core_ext/bignum'
+require 'origen/core_ext/integer'
 require 'origen/core_ext/numeric'
 require 'origen/core_ext/module'
 require 'origen/core_ext/hash'

data/lib/origen/core_ext/enumerable.rb

@@ -1,5 +1,5 @@
 module Enumerable
-  PRIMATIVES = [TrueClass, FalseClass, NilClass, Integer, Float, String, Symbol, Regexp, Complex, Rational, Fixnum, Bignum]
+  PRIMATIVES = [TrueClass, FalseClass, NilClass, String, Symbol, Regexp, Numeric]
 
   def debug(msg)
     Origen.log.debug(msg)
@@ -48,7 +48,7 @@ module Enumerable
           end
           next
         else
-          next unless options[:select].empty? || options[:select].include?(item.class) || PRIMATIVES.include?(item.class)
+          next unless options[:select].empty? || options[:select].include?(item.class) || PRIMATIVES.any? { |klass| item.is_a?(klass) }
           next if options[:ignore].include?(item.class)
           case item
           when NilClass

data/lib/origen/core_ext/integer.rb

@@ -0,0 +1,85 @@
+# The base class of ALL integers, i.e. including Fixum and Bignum
+
+# Shim to handle Ruby < 2.4.0, where [] is implemented in Fixnum/Bignum instead
+# of Integer
+module Origen
+  module IntegerExtension
+    def [](*args)
+      if args.length == 1 && !args.first.is_a?(Range)
+        super
+      else
+        if args.first.is_a?(Range)
+          msb = args.first.first
+          lsb = args.first.last
+        else
+          msb = args.first
+          lsb = args.last
+        end
+        (self >> lsb) & 0.ones_comp(msb - lsb + 1)
+      end
+    end
+  end
+end
+
+class Integer
+  if RUBY_VERSION >= '2.4.0'
+    prepend Origen::IntegerExtension
+  end
+
+  # Implements 10.cycles
+  def cycles
+    if block_given?
+      times do
+        yield
+        Origen.app.tester.cycle
+      end
+    else
+      Origen.app.tester.cycle(repeat: self)
+    end
+  end
+  alias_method :cycle, :cycles
+
+  def ones_comp(num_bits)
+    self ^ ((1 << num_bits) - 1)
+  end
+  alias_method :ones_complement, :ones_comp
+  alias_method :ones_compliment, :ones_comp
+
+  # Returns a bit mask for the given number of bits:
+  #
+  #   4.to_bit_mask  # => 0x1111
+  def to_bit_mask
+    (1 << self) - 1
+  end
+  alias_method :bit_mask, :to_bit_mask
+
+  def to_bool
+    if self == 1
+      return true
+    elsif self == 0
+      return false
+    else
+      return nil
+    end
+  end
+
+  def to_spreadsheet_column
+    index_hash = Hash.new { |hash, key| hash[key] = hash[key - 1].next }.merge(0 => 'A')
+    index_hash[self]
+  end
+  alias_method :to_xls_column, :to_spreadsheet_column
+  alias_method :to_xlsx_column, :to_spreadsheet_column
+  alias_method :to_xls_col, :to_spreadsheet_column
+  alias_method :to_xlsx_col, :to_spreadsheet_column
+  alias_method :to_spreadsheet_col, :to_spreadsheet_column
+end
+
+if RUBY_VERSION <= '2.4.0'
+  class Fixnum
+    prepend Origen::IntegerExtension
+  end
+
+  class Bignum
+    prepend Origen::IntegerExtension
+  end
+end

data/lib/origen/core_ext/numeric.rb

@@ -1,6 +1,30 @@
+# The base class of all numbers, i.e. integers and floats
 class Numeric
-  def undefined?
-    false
+  # Helpers for cases where a method may return a 0, 1 or an instance
+  # of Origen::Value::X or Origen::Value::Z
+
+  def z?;
+    false;
+  end
+
+  def hi_z?;
+    false;
+  end
+
+  def x?;
+    false;
+  end
+
+  def undefined?;
+    false;
+  end
+
+  def x_or_z?;
+    false;
+  end
+
+  def z_or_x?;
+    false;
   end
 
   def to_hex
@@ -65,13 +89,13 @@ class Numeric
 
   # Msps ==> Mega samples per second
 
-  %w(GHz Ghz GTs Gts Gsps).each do |m|
+  %w(GHz Ghz GTs Gts Gsps Gbps).each do |m|
     define_method m do
       self * 1_000_000_000
     end
   end
 
-  %w(MHz Mhz MTs Mts Msps).each do |m|
+  %w(MHz Mhz MTs Mts Msps Mbps).each do |m|
     define_method m do
       self * 1_000_000
     end

data/lib/origen/global_app.rb

@@ -0,0 +1,9 @@
+class OrigenGlobalApplication < Origen::Application
+  config.output_directory do
+    "#{Origen.root}/origen"
+  end
+
+  config.reference_directory do
+    "#{Origen.root}/origen/.ref"
+  end
+end

data/lib/origen/log.rb

@@ -35,7 +35,7 @@ module Origen
     end
 
     def console_only?
-      self.class.console_only? || !Origen.app
+      self.class.console_only? || !Origen.app || Origen.running_globally?
     end
 
     # Anything executed within the given block will log to the console only

data/lib/origen/model_initializer.rb

@@ -14,7 +14,7 @@ module Origen
         x.send(:init_sub_blocks, *args) if x.respond_to?(:init_sub_blocks)
         if x.respond_to?(:version=)
           version = options[:version]
-          version ||= args.first if args.first.is_a?(Fixnum)
+          version ||= args.first if args.first.is_a?(Integer)
           x.version = version
         end
         if x.respond_to?(:parent=)
@@ -47,6 +47,11 @@ module Origen
         is_top_level = x.respond_to?(:includes_origen_top_level?)
         if x.respond_to?(:wrap_in_controller)
           x = x.wrap_in_controller
+          # If this object has been instantiated after on_create has already been called,
+          # then invoke it now
+          if Origen.application_loaded? && Origen.app.on_create_called?
+            x.controller.on_create if x.controller.respond_to?(:on_create)
+          end
         end
         if is_top_level
           Origen.app.listeners_for(:on_top_level_instantiated, top_level: false).each do |listener|

data/lib/origen/netlist/list.rb

@@ -49,7 +49,7 @@ module Origen
               else
                 from_proc = false
               end
-              if val.is_a?(Fixnum)
+              if val.is_a?(Integer)
                 bits << Registers::Bit.new(nil, index, access: :ro, data: (i == '*' && !from_proc) ? val[index] : val)
               elsif val
                 vp, vi = *to_v(val)
@@ -122,7 +122,7 @@ module Origen
       end
 
       def clean(path)
-        if path.is_a?(Fixnum)
+        if path.is_a?(Integer)
           { path: path, numeric: true }
         elsif path.is_a?(Proc)
           { path: path, proc: true }

data/lib/origen/org_file.rb

@@ -0,0 +1,125 @@
+module Origen
+  class OrgFile
+    autoload :Interceptor,   'origen/org_file/interceptor'
+    autoload :Interceptable, 'origen/org_file/interceptable'
+
+    class << self
+      def new(*args, &block)
+        if @internal_new
+          super
+        else
+          open(*args, &block)
+        end
+      end
+
+      def open(id, options = {})
+        fail "An org_file is already open with id: #{id}" if open_files[id]
+        @internal_new = true
+        f = OrgFile.new(id, options)
+        @internal_new = nil
+        open_files[id] = f
+        if block_given?
+          yield f
+          close(id, options)
+        else
+          f
+        end
+      end
+
+      def close(id, options = {})
+        fail "An org_file with this ID has not been opened id: #{id}" unless open_files[id]
+        open_files[id].close unless options[:_internal_org_file_call_]
+        open_files[id] = nil
+      end
+
+      def org_file(id = nil)
+        id ? open_files[id] : open_files.to_a.last[1]
+      end
+
+      def cycle(number = 1)
+        open_files.each { |id, f| f.cycle(number) }
+      end
+
+      private
+
+      def open_files
+        @open_files ||= {}.with_indifferent_access
+      end
+    end
+
+    attr_accessor :path, :filename
+    attr_reader :id, :operation
+
+    def initialize(id, options = {})
+      @id = id
+      @path = options[:path] || default_filepath
+      @filename = options[:filename] || "#{id}.org"
+      FileUtils.mkdir_p(path)
+      @path_to_file = File.join(path, filename)
+    end
+
+    def default_filepath
+      "#{Origen.root}/pattern/org/#{Origen.target.name}"
+    end
+
+    def file
+      @file ||= begin
+        if operation == 'r'
+          fail "No org file found at: #{@path_to_file}" unless exist?
+        end
+        File.open(@path_to_file, operation)
+      end
+    end
+
+    def exist?
+      File.exist?(@path_to_file)
+    end
+
+    def close
+      # Corner case, if no call to read_line or record was made then no file was created and there
+      # is no file to close
+      if @file
+        file.puts "#{@buffer}#{@buffer_cycles}" if @buffer
+        file.close
+      end
+      self.class.close(id, _internal_org_file_call_: true)
+      nil
+    end
+
+    def read_line
+      @operation ||= 'r'
+      operations = file.readline.strip.split(';')
+      cycles = operations.pop.to_i
+      operations = operations.map { |op| op.split(',') }.map { |op| op[0] = eval(op[0]); op }
+      if block_given?
+        yield operations, cycles
+      else
+        [operations, cycles]
+      end
+    end
+
+    def record(path_to_object, method, *args)
+      @operation ||= 'w'
+      @line ||= ''
+      @line += "#{path_to_object},#{method}"
+      @line += ",#{args.join(',')}" unless args.empty?
+      @line += ';'
+    end
+
+    def cycle(number)
+      if @buffer
+        if @line == @buffer
+          @buffer_cycles += 1
+        else
+          file.puts "#{@buffer}#{@buffer_cycles}"
+          @buffer = @line
+          @buffer_cycles = 1
+        end
+      else
+        @buffer = @line
+        @buffer_cycles = 1
+      end
+      @line = nil
+    end
+  end
+end

data/lib/origen/org_file/interceptable.rb

@@ -0,0 +1,44 @@
+module Origen
+  class OrgFile
+    module Interceptable
+      def self.included(base)
+        base.extend ClassMethods
+
+        # Defers this executing until the whole class has loaded
+        Origen.after_app_loaded do
+          unless (base.instance_methods - Object.methods).include?(:global_path_to)
+            puts 'When adding the OrgFile::Interceptable module to a class, the class must define an instance method called "global_path_to", like this:'
+            puts
+            puts '  # Must return a string that contains a global path to access the given object,'
+            puts '  # here for example if the object was a pin'
+            puts '  def global_path_to'
+            puts '    "dut.pins(:#{id})"'
+            puts '  end'
+            fail "Incomplete integration of OrgFile::Interceptable in #{base}"
+          end
+        end
+      end
+
+      module ClassMethods
+        def new(*args, &block)
+          o = allocate
+          i = OrgFile::Interceptor.new(o)
+          o.__interceptor__ = i
+          i.send(:initialize, *args, &block)
+          i
+        end
+      end
+
+      # Class which include OrgFile::Interceptor should use 'myself' anytime then want to reference 'self',
+      # this ensures that there are never any references to the unwrapped object
+      def myself
+        @__interceptor__
+      end
+
+      # @api private
+      def __interceptor__=(obj)
+        @__interceptor__ = obj
+      end
+    end
+  end
+end

data/lib/origen/org_file/interceptor.rb

@@ -0,0 +1,100 @@
+require 'set'
+module Origen
+  class OrgFile
+    # @api private
+    #
+    # Helper for the Interceptor where block_given? doesn't work internally
+    def self._block_given_?(&block)
+      block_given?
+    end
+
+    class Interceptor < ::BasicObject
+      def initialize(object, options = {})
+        @object = object
+        @@locked = false unless defined? @@locked
+      end
+
+      def inspect(*args)
+        @object.inspect(*args)
+      end
+
+      def ==(obj)
+        if obj.respond_to?(:__org_file_interceptor__)
+          @object == obj.__object__
+        else
+          @object == obj
+        end
+      end
+      alias_method :equal?, :==
+
+      def record_to_org_file(id = nil, options = {})
+        id, options = nil, id if id.is_a?(::Hash)
+        if options[:only]
+          @org_file_methods_to_intercept = Array(options[:only]).to_set
+        else
+          @org_file_methods_to_intercept = default_org_file_captures
+          if options[:also]
+            @org_file_methods_to_intercept += Array(options[:also]).to_set
+          end
+        end
+        @org_file ||= @old_org_file || OrgFile.org_file(id)
+      end
+
+      # Temporarily stop recording operations within the given block, or stop recording
+      # completely if no block given
+      def stop_recording_to_org_file(&block)
+        @old_org_file = @org_file
+        if OrgFile._block_given_?(&block)
+          @org_file = nil
+          yield
+          @org_file = @old_org_file
+        else
+          @org_file = nil
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if !@@locked && @org_file && @org_file_methods_to_intercept.include?(method)
+          @org_file.record(@object.global_path_to, method, *args)
+          # Locking prevents an operation on an intercepted container object trigger from generating multiple
+          # org file entries if its contained objects are also intercepted. e.g. Imagine this is a pin group, we
+          # want the org file to reflect the operation called on the pin group, but not the many subsequent internal
+          # operations as the group proxies the operation to its contained pins
+          @@locked = true
+          @object.send(method, *args, &block)
+          @@locked = false
+        else
+          @object.send(method, *args, &block)
+        end
+      end
+
+      def respond_to?(method, include_private = false)
+        method == :__org_file_interceptor__ ||
+          @object.respond_to?(method, include_private)
+      end
+
+      def __org_file_interceptor__
+        true
+      end
+
+      # @api private
+      #
+      # Don't ever use this! An un-wrapped reference to an object must never make it into
+      # application code or else any operations called on the un-wrapped reference will not
+      # be captured.
+      def __object__
+        @object
+      end
+
+      private
+
+      def debugger
+        ::Kernel.debugger
+      end
+
+      def default_org_file_captures
+        @default_captures ||= Array(@object.try(:org_file_intercepted_methods)).to_set
+      end
+    end
+  end
+end