ruby-vpi 19.0.0 → 20.0.0

data/lib/ruby-vpi/core/edge.rb

@@ -3,10 +3,11 @@
 # Copyright 2007 Suraj N. Kurapati
 # See the file named LICENSE for details.
 
-require 'singleton'
+require File.join(File.dirname(__FILE__), 'edge-methods.rb')
 
 module RubyVPI
   class EdgeClass #:nodoc:
+    require 'singleton'
     include Singleton
 
     def initialize
@@ -40,7 +41,7 @@ module RubyVPI
     # Remember the current value as the "previous" value.
     def refresh_handle aHandle
       aHandle.instance_eval do
-        @__edge__prev_val = get_value(VpiHexStrVal)
+        @__edge__prev_val = get_value(VpiScalarVal)
       end
     end
   end
@@ -48,34 +49,11 @@ module RubyVPI
   Edge = EdgeClass.instance
 end
 
-module VPI
-  class Handle
-    # create methods for detecting all possible value changes
-    vals  = %w[0 1 x z]
-    edges = vals.map {|a| vals.map {|b| a + b}}.flatten
-
-    edges.each do |edge|
-      meth = "change_#{edge}?"
-      old, new = edge.split(//)
-
-      old_int  = old =~ /[01]/
-      new_int  = new =~ /[01]/
 
-      old_read = old_int ? 'int' : 'hex'
-      new_read = new_int ? 'VpiIntVal' : 'VpiHexStrVal'
 
-      old_test = old_int ? "== #{old}" : "=~ /#{old}/i"
-      new_test = new_int ? "== #{new}" : "=~ /#{new}/i"
-
-      class_eval %{
-        def #{meth}
-          old = __edge__prev_val_#{old_read}
-          new = get_value(#{new_read})
-
-          old #{old_test} and new #{new_test}
-        end
-      }
-    end
+module VPI
+  class Handle
+    RubyVPI::EdgeClass::DETECTION_METHODS.each {|m| class_eval m.body}
 
     alias posedge? change_01?
     alias negedge? change_10?
@@ -88,24 +66,11 @@ module VPI
     # Tests if the logic value of this handle has
     # changed since the last simulation time step.
     def change?
-      old = __edge__prev_val_hex
-      new = get_value(VpiHexStrVal)
+      old = @__edge__prev_val
+      new = get_value(VpiScalarVal)
 
       old != new
     end
-
-
-    private
-
-    # Returns the previous value as a hex string.
-    def __edge__prev_val_hex #:nodoc:
-      @__edge__prev_val.to_s
-    end
-
-    # Returns the previous value as an integer.
-    def __edge__prev_val_int #:nodoc:
-      __edge__prev_val_hex.to_i(16)
-    end
   end
 
   %w[

data/lib/ruby-vpi/core/handle.rb

@@ -3,96 +3,112 @@
 # Copyright 2006 Suraj N. Kurapati
 # See the file named LICENSE for details.
 
+require 'ruby-vpi/util'
+
 module VPI
   Handle = SWIG::TYPE_p_unsigned_int
 
   # A handle is an object inside a Verilog simulation (see
-  # *vpiHandle* in IEEE Std.  1364-2005).  VPI types and
-  # properties listed in ext/vpi_user.h can be specified by
-  # their names (strings or symbols) or integer constants.
+  # *vpiHandle* in IEEE Std.  1364-2005 for details).
   #
-  # = Example names
-  # * "intVal"
-  # * :intVal
-  # * "vpiIntVal"
-  # * :vpiIntVal
-  # * "VpiIntVal"
-  # * :VpiIntVal
+  # Nearly all methods of this class, such as put_value()
+  # and get_value(), you allow you to specify VPI types
+  # and properties (which are listed in ext/vpi_user.h) by
+  # their names (strings or symbols) or integer constants.
   #
-  # = Example constants
-  # * VpiIntVal
-  # * VpiModule
-  # * VpiReg
+  # For example, the vpiIntVal property can be specified as a string
+  # (<code>"vpiIntVal"</code>), a symbol (<code>:vpiIntVal</code>), or as
+  # an integer (<code>VpiIntVal</code> or <code>VPI::vpiIntVal</code>).
   #
   class Handle
     include VPI
 
+    #---------------------------------------------------------------------------
+    # testing & setting common logic values
+    #---------------------------------------------------------------------------
+
+    # Tests if the integer value of this handle is 1.
+    def vpi1?
+      get_value(VpiScalarVal) == Vpi1
+    end
+
+    # Sets the integer value of this handle to 1.
+    def vpi1!
+      put_value(Vpi1, VpiScalarVal)
+    end
+
+    alias t? vpi1?
+    alias t! vpi1!
+
+
+    # Tests if the integer value of this handle is 0.
+    def vpi0?
+      get_value(VpiScalarVal) == Vpi0
+    end
+
+    # Sets the integer value of this handle to 0.
+    def vpi0!
+      put_value(Vpi0, VpiScalarVal)
+    end
+
+    alias f? vpi0?
+    alias f! vpi0!
+
+
     # Tests if the logic value of this handle is unknown (x).
-    def x?
-      get_value(VpiHexStrVal) =~ /x/i
+    def vpiX?
+      get_value(VpiScalarVal) == VpiX
     end
 
     # Sets the logic value of this handle to unknown (x).
-    def x!
-      put_value('x', VpiHexStrVal)
+    def vpiX!
+      put_value(VpiX, VpiScalarVal)
     end
 
-    alias unknown? x?
-    alias unknown! x!
+    alias x? vpiX?
+    alias x! vpiX!
 
-    alias dont_care? x?
-    alias dont_care! x!
 
     # Tests if the logic value of this handle is high impedance (z).
-    def z?
-      get_value(VpiHexStrVal) =~ /z/i
+    def vpiZ?
+      get_value(VpiScalarVal) == VpiZ
     end
 
     # Sets the logic value of this handle to high impedance (z).
-    def z!
-      put_value('z', VpiHexStrVal)
+    def vpiZ!
+      put_value(VpiZ, VpiScalarVal)
     end
 
-    alias hi_z? z?
-    alias hi_z! z!
+    alias z? vpiZ?
+    alias z! vpiZ!
 
-    alias high_z? z?
-    alias high_z! z!
 
-    alias high_impedance? z?
-    alias high_impedance! z!
-
-    alias tri_state? z?
-    alias tri_state! z!
-
-    alias floating? z?
-    alias floating! z!
-
-    # Tests if the logic value of this handle is at "logic high" level.
-    def high?
-      get_value(VpiIntVal) != 0
+    # Tests if the strength value of this handle is high.
+    def vpiH?
+      get_value(VpiScalarVal) == VpiH
     end
 
-    # Sets the logic value of this handle to "logic high" level.
-    def high!
-      put_value(1, VpiIntVal)
+    # Sets the strength value of this handle to high.
+    def vpiH!
+      put_value(VpiH, VpiScalarVal)
     end
 
-    alias one? high?
-    alias one! high!
+    alias h? vpiH?
+    alias h! vpiH!
 
-    # Tests if the logic value of this handle is at "logic low" level.
-    def low?
-      get_value(VpiHexStrVal) =~ /^0+$/
+
+    # Tests if the strength value of this handle is low.
+    def vpiL?
+      get_value(VpiScalarVal) == VpiL
     end
 
-    # Sets the logic value of this handle to "logic low" level.
-    def low!
-      put_value(0, VpiIntVal)
+    # Sets the strength value of this handle to low.
+    def vpiL!
+      put_value(VpiL, VpiScalarVal)
     end
 
-    alias zero? low?
-    alias zero! low!
+    alias l? vpiL?
+    alias l! vpiL!
 
 
     # Inspects the given VPI property names, in
@@ -130,9 +146,9 @@ module VPI
       @size ||= vpi_get(VpiSize, self)
 
       if fmt == VpiIntVal and @size > INTEGER_BITS
-        fmt = VpiHexStrVal
+        fmt = VpiBinStrVal
         val = get_value_wrapper(fmt)
-        val.read(fmt).to_i(16)
+        val.read(fmt).gsub(/[^01]/, '0').to_i(2)
       else
         val = get_value_wrapper(fmt)
         val.read(fmt)
@@ -142,14 +158,14 @@ module VPI
     # Writes the given value using the given format (name or integer
     # constant), time, and delay, and then returns the written value.
     #
-    # * If a format is not given, then the Verilog simulator
-    #   will attempt to determine the correct format.
+    # * If you do not specify the format, then the Verilog
+    #   simulator will attempt to determine the correct format.
     #
     def put_value aValue, aFormat = nil, aTime = nil, aDelay = VpiNoDelay
       if vpi_get(VpiType, self) == VpiNet
         aDelay = VpiForceFlag
 
-        if driver = self[VpiDriver].find {|d| vpi_get(VpiType, d) != VpiForce}
+        if driver = self.to_a(VpiDriver).find {|d| vpi_get(VpiType, d) != VpiForce}
           warn "forcing value #{aValue.inspect} onto wire #{self} that is already driven by #{driver.inspect}"
         end
       end
@@ -187,7 +203,7 @@ module VPI
       put_value(*args)
     end
 
-    # Releases a previously forced value on this handle.
+    # Releases all forced values on this handle (if any).
     def release_value
       # this doesn't really change the value, it only removes the force flag
       put_value(0, VpiIntVal, nil, VpiReleaseFlag)
@@ -195,7 +211,7 @@ module VPI
 
     # Tests if there is currently a value forced onto this handle.
     def force?
-      self[VpiDriver].any? {|d| vpi_get(VpiType, d) == VpiForce}
+      self.to_a(VpiDriver).any? {|d| vpi_get(VpiType, d) == VpiForce}
     end
 
 
@@ -203,12 +219,17 @@ module VPI
     # accessing related handles / traversing the hierarchy
     #---------------------------------------------------------------------------
 
-    # Returns an array of child handles of the
-    # given types (name or integer constant).
-    def [] *aTypes
+    # Returns the child handle at the given relative VPI path.
+    def / aRelativePath
+      access_child(aRelativePath)
+    end
+
+    # Returns an array of child handles which have
+    # the given types (names or integer constants).
+    def to_a *aChildTypes
       handles = []
 
-      aTypes.each do |arg|
+      aChildTypes.each do |arg|
         t = resolve_prop_type(arg)
 
         if itr = vpi_iterate(t, self)
@@ -222,20 +243,21 @@ module VPI
     end
 
     # inherit Enumerable methods, such as #each, #map, #select, etc.
-    Enumerable.instance_methods.push('each').each do |meth|
-      # using a string because define_method
-      # does not accept a block until Ruby 1.9
-      class_eval %{
-        def #{meth}(*args, &block)
-          if ary = self[*args]
-            ary.#{meth}(&block)
+      list = Enumerable.instance_methods
+      list.delete 'to_a'
+      list.push 'each'
+
+      list.each do |meth|
+        # using a string because define_method
+        # does not accept a block until Ruby 1.9
+        class_eval %{
+          def #{meth}(*args, &block)
+            if ary = self.to_a(*args)
+              ary.#{meth}(&block)
+            end
           end
-        end
-      }, __FILE__, __LINE__
-    end
-
-    # bypass Enumerable's #to_a method, which relies on #each
-    alias to_a []
+        }, __FILE__, __LINE__
+      end
 
     # Sort by absolute VPI path.
     def <=> other
@@ -247,17 +269,23 @@ module VPI
     # accessing VPI properties
     #---------------------------------------------------------------------------
 
-    @@propCache = Hash.new {|h, k| h[k] = Property.new(k)}
+    # Returns the value of the given VPI property
+    # (name or integer constant) of this handle.
+    def [] aProp
+      access_prop(aProp)
+    end
+
+    @@propCache = Hash.new {|h,k| h[k] = Property.new(k)}
 
-    undef type # used to access VpiType
+    undef id    # deprecated in Ruby 1.8
+    undef type  # used to access VpiType
 
-    # Provides access to this handle's (1) child handles
-    # and (2) VPI properties through method calls.  In the
-    # case that a child handle has the same name as a VPI
-    # property, the child handle will be accessed instead
-    # of the VPI property.  However, you can still access
-    # the VPI property via #get_value and #put_value.
-    def method_missing aMeth, *aArgs, &aBlockArg
+    # Provides access to this handle's (1) child handles and (2) VPI
+    # properties through method calls.  In the case that a child handle
+    # has the same name as a VPI property, the child handle will be
+    # accessed instead of the VPI property.  However, you can still
+    # access the VPI property using the square brackets #[] method.
+    def method_missing aMeth, *aArgs, &aBlock
       # cache the result for future accesses, in order
       # to cut down number of calls to method_missing()
       eigen_class = (class << self; self; end)
@@ -275,16 +303,24 @@ module VPI
         #      not support a block argument until Ruby 1.9
         eigen_class.class_eval %{
           def #{aMeth}(*a, &b)
-            @@propCache[#{aMeth.inspect}].execute(self, *a, &b)
+            access_prop(#{aMeth.inspect}, *a, &b)
           end
         }, __FILE__, __LINE__
 
-        __send__(aMeth, *aArgs, &aBlockArg)
+        __send__(aMeth, *aArgs, &aBlock)
       end
     end
 
     private
 
+    def access_child aPath
+      vpi_handle_by_name(aPath.to_s, self)
+    end
+
+    def access_prop aProp, *aArgs, &aBlock
+      @@propCache[aProp.to_sym].execute(self, *aArgs, &aBlock)
+    end
+
     class Property # :nodoc:
       attr_reader :name, :type, :accessor, :operation
 
@@ -399,7 +435,7 @@ module VPI
             if @isAssign
               raise NotImplementedError
             else
-              aHandle[@type]
+              aHandle.to_a(@type)
             end
 
           else

data/lib/ruby-vpi/core/scheduler.rb

@@ -33,25 +33,24 @@ module RubyVPI
 
     def initialize
       @thread2task = { Thread.main => Task.new(Thread.main, :run) }
-      @thread2task_sw = @thread2task.dup  # software threads
-      @thread2task_hw = {}                # hardware threads (Ruby prototype of DUT)
+      @thread2task_soft = @thread2task.dup  # software threads
+      @thread2task_hard = {} # hardware threads (Ruby prototype of DUT)
       @thread2task_lock = Mutex.new
 
-
       # base case: hardware runs first before any software does at startup
-      @time = 0
+        @time = 0
 
-      unless RubyVPI::USE_PROTOTYPE
-        Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
-      end
+        unless RubyVPI::USE_PROTOTYPE
+          Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
+        end
 
       @scheduler = Thread.new do
-        # pause because boot loader is not fully init yet
+        # pause because boot loader is not fully initialized yet
         Thread.stop
 
         loop do
           # run software in current time step
-            run_tasks @thread2task_sw, true
+            run_tasks @thread2task_soft, true
             Edge.refresh_cache
 
             # go to time slot where writing is permitted before flushing writes
@@ -65,7 +64,7 @@ module RubyVPI
             @time += 1
 
             if RubyVPI::USE_PROTOTYPE
-              run_tasks @thread2task_hw, false
+              run_tasks @thread2task_hard, false
               flush_writes
             else
               Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
@@ -92,9 +91,9 @@ module RubyVPI
 
       hash =
         if caller.grep(/_proto\.rb/).empty?
-          @thread2task_sw
+          @thread2task_soft
         else
-          @thread2task_hw
+          @thread2task_hard
         end
 
       @thread2task_lock.synchronize do
@@ -110,8 +109,8 @@ module RubyVPI
 
       @thread2task_lock.synchronize do
         @thread2task.delete key
-        @thread2task_hw.delete key
-        @thread2task_sw.delete key
+        @thread2task_hard.delete key
+        @thread2task_soft.delete key
       end
     end
 
@@ -168,7 +167,7 @@ module RubyVPI
         tasks = aHash.values
         tasks.each {|t| t.run}
 
-        if aExitWhenEmpty and tasks.empty?
+        if aExitWhenEmpty && tasks.empty?
           Thread.exit
         end
       end

data/lib/ruby-vpi/core.rb

@@ -26,7 +26,7 @@ module VPI
 end
 
 module RubyVPI
-  SIMULATOR     = ENV['RUBYVPI_SIMULATOR'].to_sym
+  USE_SIMULATOR = ENV['RUBYVPI_SIMULATOR'].to_sym
   USE_DEBUGGER  = ENV['DEBUGGER'].to_i  == 1
   USE_COVERAGE  = ENV['COVERAGE'].to_i  == 1
   USE_PROTOTYPE = ENV['PROTOTYPE'].to_i == 1

data/lib/ruby-vpi/rake.rb

@@ -8,13 +8,11 @@ require 'fileutils'
 module FileUtils
   alias old_sh sh
 
-  # An improved sh() that also accepts arrays as arguments.
+  # An improved sh() that accepts arrays as arguments, omits empty string
+  # arguments, and shows users exactly what ARGV is being executed.
   def sh *aArgs, &aBlock
-    old_sh(*collect_args(aArgs).reject {|i| i.to_s.empty?}, &aBlock)
-  end
-
-  # Collects the given arguments into a single, sparse array.
-  def collect_args *aArgs
-    aArgs.flatten.compact
+    args = aArgs.flatten.compact.reject {|i| i.to_s.empty?}
+    STDERR.puts args.inspect
+    old_sh(*args, &aBlock)
   end
 end

data/lib/ruby-vpi/rcov.rb

@@ -13,21 +13,16 @@ require 'rcov'
       include Markup
 
       def xmlish_ *a, &b
-        xx_which(XMLish){ xx_with_doc_in_effect(*a, &b)}
+        xx_which(XMLish) { xx_with_doc_in_effect(*a, &b) }
       end
     end
   end
 
-  require 'cgi'
-
 require 'rcov/report'
 
 
-module RubyVPI::Coverage #:nodoc:
-end
-
 module RubyVPI
-  module Coverage
+  module Coverage #:nodoc:
     @@analyzer = Rcov::CodeCoverageAnalyzer.new
 
     def Coverage.start

data/lib/ruby-vpi/runner.rb

@@ -18,18 +18,20 @@
 
 require 'ruby-vpi/util'
 
+# go into same directory as the test runner file
+  dir = File.dirname(caller.reject {|s| s =~ /:in /}.first.rstrip_from(':'))
+  cd dir unless Rake.original_dir == dir
+
 # check for required variables
-  vars = %w[SIMULATOR_SOURCES SIMULATOR_ARGUMENTS]
+  vars = %w[TEST_LOADER SIMULATOR_SOURCES SIMULATOR_ARGUMENTS]
 
   unless vars.all? {|v| eval "defined? #{v}"}
     raise ArgumentError, "#{vars.join(' and ')} must be defined."
   end
 
-# auto-detect and set default parameters
-  runnerPath = caller.grep(/runner\.rake/).first.rstrip_from(':')
-  @target    = File.basename(runnerPath).rstrip_from('_')
-
-  task :setup
+  raise ArgumentError, "The path specified by TEST_LOADER does not exist: #{TEST_LOADER.inspect}" unless File.exist? TEST_LOADER
+  raise ArgumentError, "The path specified by TEST_LOADER does not refer to a file: #{TEST_LOADER.inspect}" unless File.file? TEST_LOADER
+  raise ArgumentError, "The path specified by TEST_LOADER is not readable: #{TEST_LOADER.inspect}" unless File.readable? TEST_LOADER
 
 # resolve paths to sources by searching include directories
   @sources = SIMULATOR_SOURCES.to_a.uniq
@@ -53,10 +55,10 @@ require 'ruby-vpi/util'
 
 # prepare hook for rb_load_file() in main.c
   ENV['RUBYVPI_BOOT_LOADER'] = File.join(File.dirname(__FILE__), 'runner_boot_loader.rb')
-  ENV['RUBYVPI_BOOT_TARGET'] = @target
+  ENV['RUBYVPI_TEST_LOADER'] = TEST_LOADER
 
 # check if the machine is 64-bit
-  @archIs64 = -1.size == 8
+  @archIs64 = 0.size == 8
 
 
 require 'rake/clean'
@@ -86,7 +88,7 @@ end
 
 # Creates a new task for running the given simulator.
 def sim_task aSimId #:nodoc:
-  desc "Simulate with #{RubyVPI::SIMULATORS[aSimId].name}."
+  desc "Simulate with #{RubyVPI::SIMULATORS.find_by_id(aSimId).name}."
   task aSimId => :setup do
     ENV['RUBYVPI_SIMULATOR'] = aSimId.to_s
     yield aSimId
@@ -94,6 +96,10 @@ def sim_task aSimId #:nodoc:
 end
 
 
+desc "User-defined task that is invoked before the simulator runs."
+task :setup
+
+
 desc "Show a list of available tasks."
 task :default do
   Rake.application.options.show_task_pattern = //
@@ -143,8 +149,7 @@ sim_task :vsim do |id|
   sh %w[vsim -c],
     '-do', 'run -all; exit',
     '-pli', object_file_path(id),
-    SIMULATOR_ARGUMENTS[id],
-    @target
+    SIMULATOR_ARGUMENTS[id]
 end
 
 CLEAN.include 'work', 'vsim.wlf'