ruby-vpi 18.0.2 → 19.0.0

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

@@ -0,0 +1,244 @@
+# Concurrent processes.
+#--
+# Copyright 2007 Suraj N. Kurapati
+# See the file named LICENSE for details.
+
+Thread.abort_on_exception = true
+
+require 'singleton'
+
+module RubyVPI
+  class SchedulerClass #:nodoc:
+    include Singleton
+
+
+    Task = Struct.new(:thread, :state)
+
+    class Task #:nodoc:
+      def run
+        self.state = :run
+        self.thread.wakeup
+      end
+
+      def stop
+        self.state = :wait
+        Thread.stop
+      end
+
+      def stop?
+        self.thread.stop? and self.state == :wait
+      end
+    end
+
+
+    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_lock = Mutex.new
+
+
+      # base case: hardware runs first before any software does at startup
+      @time = 0
+
+      unless RubyVPI::USE_PROTOTYPE
+        Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
+      end
+
+      @scheduler = Thread.new do
+        # pause because boot loader is not fully init yet
+        Thread.stop
+
+        loop do
+          # run software in current time step
+            run_tasks @thread2task_sw, true
+            Edge.refresh_cache
+
+            # go to time slot where writing is permitted before flushing writes
+            unless RubyVPI::USE_PROTOTYPE
+              Callback.relay_verilog(VPI::CbAfterDelay, 1)
+            end
+
+            flush_writes
+
+          # run hardware in next time step
+            @time += 1
+
+            if RubyVPI::USE_PROTOTYPE
+              run_tasks @thread2task_hw, false
+              flush_writes
+            else
+              Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
+            end
+        end
+      end
+
+
+      @handle2write = Hash.new {|h,k| h[k] = []}
+      @handle2write_lock = Mutex.new
+    end
+
+    def current_time
+      @time
+    end
+
+    def start
+      @scheduler.wakeup
+    end
+
+    # Registers the calling thread with the scheduler.
+    def attach
+      key = Thread.current
+
+      hash =
+        if caller.grep(/_proto\.rb/).empty?
+          @thread2task_sw
+        else
+          @thread2task_hw
+        end
+
+      @thread2task_lock.synchronize do
+        task = Task.new(key, :run)
+        hash[key] = task
+        @thread2task[key] = task
+      end
+    end
+
+    # Unregisters the calling thread from the scheduler.
+    def detach
+      key = Thread.current
+
+      @thread2task_lock.synchronize do
+        @thread2task.delete key
+        @thread2task_hw.delete key
+        @thread2task_sw.delete key
+      end
+    end
+
+    # Waits for the scheduler to arrive in the next time step.
+    def await
+      key = Thread.current
+
+      task = @thread2task_lock.synchronize do
+        @thread2task[key]
+      end
+
+      task.stop
+    end
+
+    def ensure_caller_is_registered
+      unless @thread2task_lock.synchronize {@thread2task.key? Thread.current}
+        raise SecurityError, 'This method may only be invoked from within a process (see the VPI::process() method).'
+      end
+    end
+
+    Write = Struct.new :thread, :trace, :args
+
+    # Captures the given write operation so it
+    # can be flushed later, at the correct time.
+    def capture_write aHandle, *aArgs
+      @handle2write_lock.synchronize do
+        @handle2write[aHandle] << Write.new(Thread.current, caller, aArgs)
+      end
+    end
+
+    private
+
+    # Flushes all captured writes.
+    def flush_writes
+      @handle2write_lock.synchronize do
+        @handle2write.each_pair do |handle, writes|
+          if writes.map {|w| w.thread}.uniq.length > 1
+            culprits = writes.map {|w| "\n\n#{w.thread}" << w.trace.map {|x| "\n\t#{x}"}.join}.join
+            STDERR.puts "Race condition detected at time step #{current_time}: the logic value of handle #{handle} is being modified by more than one concurrent process: #{culprits}"
+            exit 1
+          end
+
+          writes.each do |w|
+            VPI::__scheduler__vpi_put_value(handle, *w.args)
+          end
+
+          writes.clear
+        end
+      end
+    end
+
+    def run_tasks aHash, aExitWhenEmpty
+      @thread2task_lock.synchronize do
+        tasks = aHash.values
+        tasks.each {|t| t.run}
+
+        if aExitWhenEmpty and tasks.empty?
+          Thread.exit
+        end
+      end
+
+      loop do
+        ready = @thread2task_lock.synchronize do
+          aHash.values.all? {|t| t.stop?}
+        end
+
+        if ready
+          break
+        else
+          Thread.pass
+        end
+      end
+    end
+  end
+
+  Scheduler = SchedulerClass.instance
+end
+
+module VPI
+  alias_method :__scheduler__vpi_put_value, :vpi_put_value
+  module_function :__scheduler__vpi_put_value
+
+  def vpi_put_value *args #:nodoc:
+    RubyVPI::Scheduler.capture_write(*args)
+  end
+
+
+  # Returns the current simulation time.
+  def current_time
+    RubyVPI::Scheduler.current_time
+  end
+
+  # Wait until the simulation advances by the given number of time steps.
+  def advance_time aNumTimeSteps = 1
+    RubyVPI::Scheduler.ensure_caller_is_registered
+    aNumTimeSteps.times { RubyVPI::Scheduler.await }
+  end
+
+  alias wait advance_time
+
+
+  # Creates a new concurrent process, which will execute the
+  # given block with the given arguments, and returns it.
+  def process *aBlockArgs
+    RubyVPI::Scheduler.ensure_caller_is_registered
+    raise ArgumentError, "block must be given" unless block_given?
+
+    Thread.new do
+      RubyVPI::Scheduler.attach
+      yield(*aBlockArgs)
+      RubyVPI::Scheduler.detach
+    end
+  end
+
+  # Wraps the given block inside an infinite loop and executes it
+  # inside a new concurrent process (see the VPI::process method).
+  def always *aBlockArgs, &aBlock
+    process do
+      loop do
+        startTime = VPI.current_time
+        aBlock.call(*aBlockArgs)
+        finishTime = VPI.current_time
+
+        VPI.advance_time unless finishTime > startTime
+      end
+    end
+  end
+
+  alias forever always
+end

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

@@ -0,0 +1,123 @@
+# VPI structures (S_vpi_* and S_cb_*) stuff
+#--
+# Copyright 2006 Suraj N. Kurapati
+# See the file named LICENSE for details.
+
+module VPI
+  class S_vpi_time
+    # Returns the high and low portions of
+    # this time as a single 64-bit integer.
+    def integer
+      (self.high << INTEGER_BITS) | self.low
+    end
+
+    # Sets the high and low portions of this
+    # time from the given 64-bit integer.
+    def integer= aValue
+      self.low  = aValue & INTEGER_MASK
+      self.high = (aValue >> INTEGER_BITS) & INTEGER_MASK
+    end
+
+    alias to_i integer
+    alias to_f real
+  end
+
+  class S_vpi_value
+    # Attempts to detect the format of the given value.
+    # Returns +nil+ if detection is not possible.
+    def S_vpi_value.detect_format aValue
+      if aValue.respond_to? :to_int
+        VpiIntVal
+
+      elsif aValue.respond_to? :to_float
+        VpiRealVal
+
+      elsif aValue.respond_to? :to_str
+        VpiStringVal
+
+      elsif aValue.is_a? S_vpi_time
+        VpiTimeVal
+
+      elsif aValue.is_a? S_vpi_vecval
+        VpiVectorVal
+
+      elsif aValue.is_a? S_vpi_strengthval
+        VpiStrengthVal
+      end
+    end
+
+    # Writes the given value, which has the given format.
+    def write aValue, aFormat
+      case aFormat
+      when VpiBinStrVal, VpiOctStrVal, VpiDecStrVal, VpiHexStrVal, VpiStringVal
+        value.str      = aValue.to_s
+
+      when VpiScalarVal
+        value.scalar   = aValue.to_i
+
+      when VpiIntVal
+        value.integer  = aValue.to_i
+
+      when VpiRealVal
+        value.real     = aValue.to_f
+
+      when VpiTimeVal
+        value.time     = aValue
+
+      when VpiVectorVal
+        value.vector   = aValue
+
+      when VpiStrengthVal
+        value.strength = aValue
+
+      else
+        raise "unknown format: #{aFormat.inspect}"
+      end
+    end
+
+    # Returns the value in the given format.
+    def read aFormat = self.format
+      case aFormat
+      when VpiBinStrVal, VpiOctStrVal, VpiDecStrVal, VpiHexStrVal, VpiStringVal
+        value.str.to_s
+
+      when VpiScalarVal
+        value.scalar.to_i
+
+      when VpiIntVal
+        value.integer.to_i
+
+      when VpiRealVal
+        value.real.to_f
+
+      when VpiTimeVal
+        value.time
+
+      when VpiVectorVal
+        value.vector
+
+      when VpiStrengthVal
+        value.strength
+
+      else
+        raise "unknown format: #{aFormat.inspect}"
+      end
+    end
+  end
+
+  # make VPI structs more accessible by allowing their
+  # members to be initialized through the constructor
+  constants.grep(/^S_/).each do |s|
+    const_get(s).class_eval do
+      alias __struct__initialize initialize
+
+      def initialize aMembers = {} #:nodoc:
+        __struct__initialize
+
+        aMembers.each_pair do |k, v|
+          __send__("#{k}=", v)
+        end
+      end
+    end
+  end
+end

data/lib/ruby-vpi/core.rb

@@ -0,0 +1,41 @@
+# A utility layer which transforms the VPI interface
+# into one that is more suitable for Ruby.
+#--
+# Copyright 2006 Suraj N. Kurapati
+# See the file named LICENSE for details.
+
+module VPI
+  # restore compatibility with the C language version of VPI: in Ruby,
+  # constants are capitalized, whereas in C, they do not have to be.
+  constants.grep(/^(S_|Cb|Vpi)/).each do |name|
+    meth  = name[0,1].downcase << name[1..-1]
+    value = const_get(name)
+
+    define_method meth do value end
+    module_function meth
+  end
+
+  # Number of bits in PLI_INT32.
+  INTEGER_BITS  = 32
+
+  # Lowest upper bound of PLI_INT32.
+  INTEGER_LIMIT = 2 ** INTEGER_BITS
+
+  # Bit-mask capable of capturing PLI_INT32.
+  INTEGER_MASK  = INTEGER_LIMIT - 1
+end
+
+module RubyVPI
+  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
+  USE_PROFILER  = ENV['PROFILER'].to_i   == 1
+end
+
+require 'thread'
+require 'ruby-vpi/core/struct'
+require 'ruby-vpi/core/handle'
+require 'ruby-vpi/core/edge'
+require 'ruby-vpi/core/callback'
+require 'ruby-vpi/core/scheduler'

data/lib/ruby-vpi/rcov.rb

@@ -23,23 +23,36 @@ require 'rcov'
 require 'rcov/report'
 
 
+module RubyVPI::Coverage #:nodoc:
+end
+
 module RubyVPI
-  COVERAGE_ANALYSIS = Rcov::CodeCoverageAnalyzer.new
-  COVERAGE_ANALYSIS.install_hook
+  module Coverage
+    @@analyzer = Rcov::CodeCoverageAnalyzer.new
+
+    def Coverage.start
+      @@analyzer.install_hook
+    end
+
+    def Coverage.stop
+      @@analyzer.remove_hook
+    end
 
-  COVERAGE_ANALYSIS_HANDLERS = []
 
-  at_exit do
-    COVERAGE_ANALYSIS.remove_hook
+    @@handlers = []
 
-    COVERAGE_ANALYSIS_HANDLERS.each do |a|
-      a.call COVERAGE_ANALYSIS
+    # Invokes the given block after code coverage analysis has completed.
+    def Coverage.attach &aBlock # :yield: Rcov::CodeCoverageAnalyzer
+      raise ArgumentError unless block_given?
+      @@handlers << aBlock if aBlock
     end
-  end
 
-  # Invokes the given block, which yields COVERAGE_ANALYSIS,
-  # after code coverage analysis has completed.
-  def RubyVPI.with_coverage_analysis &aBlock # :nodoc:
-    COVERAGE_ANALYSIS_HANDLERS << aBlock if aBlock
+    at_exit do
+      Coverage.stop
+
+      @@handlers.each do |h|
+        h.call @@analyzer
+      end
+    end
   end
 end

data/lib/ruby-vpi/runner.rb

@@ -26,7 +26,7 @@ require 'ruby-vpi/util'
   end
 
 # auto-detect and set default parameters
-  runnerPath = caller.grep(/runner.rake/).first.rstrip_from(':')
+  runnerPath = caller.grep(/runner\.rake/).first.rstrip_from(':')
   @target    = File.basename(runnerPath).rstrip_from('_')
 
   task :setup
@@ -84,6 +84,15 @@ def expand_incdir_options aSimId # :nodoc:
   @incdirs.map {|i| prefix + i}
 end
 
+# Creates a new task for running the given simulator.
+def sim_task aSimId #:nodoc:
+  desc "Simulate with #{RubyVPI::SIMULATORS[aSimId].name}."
+  task aSimId => :setup do
+    ENV['RUBYVPI_SIMULATOR'] = aSimId.to_s
+    yield aSimId
+  end
+end
+
 
 desc "Show a list of available tasks."
 task :default do
@@ -92,24 +101,22 @@ task :default do
 end
 
 
-desc "Simulate with #{RubyVPI::SIMULATORS[:cver].name}."
-task :cver => :setup do
+sim_task :cver do |id|
   sh 'cver',
-    "+loadvpi=#{object_file_path(:cver)}:#{LOADER_FUNC}",
-    SIMULATOR_ARGUMENTS[:cver],
-    expand_incdir_options(:cver),
+    "+loadvpi=#{object_file_path(id)}:#{LOADER_FUNC}",
+    SIMULATOR_ARGUMENTS[id],
+    expand_incdir_options(id),
     @sources
 end
 
 CLOBBER.include 'verilog.log'
 
 
-desc "Simulate with #{RubyVPI::SIMULATORS[:ivl].name}."
-task :ivl => :setup do
-  cp object_file_path(:ivl), 'ruby-vpi.vpi'
+sim_task :ivl do |id|
+  cp object_file_path(id), 'ruby-vpi.vpi'
   sh %w[iverilog -mruby-vpi],
-    SIMULATOR_ARGUMENTS[:ivl],
-    expand_incdir_options(:ivl),
+    SIMULATOR_ARGUMENTS[id],
+    expand_incdir_options(id),
     @sources
   sh 'vvp -M. a.out'
 end
@@ -117,28 +124,26 @@ end
 CLEAN.include 'ruby-vpi.vpi', 'a.out'
 
 
-desc "Simulate with #{RubyVPI::SIMULATORS[:vcs].name}."
-task :vcs => :setup do
+sim_task :vcs do |id|
   sh %w[vcs -R +v2k +vpi +cli],
     '-P', File.join(File.dirname(__FILE__), 'pli.tab'),
-    '-load', "#{object_file_path(:vcs)}:#{LOADER_FUNC}",
+    '-load', "#{object_file_path(id)}:#{LOADER_FUNC}",
     ('-full64' if @archIs64),
-    SIMULATOR_ARGUMENTS[:vcs],
-    expand_incdir_options(:vcs),
+    SIMULATOR_ARGUMENTS[id],
+    expand_incdir_options(id),
     @sources
 end
 
 CLEAN.include 'csrc', 'simv*'
 
 
-desc "Simulate with #{RubyVPI::SIMULATORS[:vsim].name}."
-task :vsim => :setup do
+sim_task :vsim do |id|
   sh 'vlib work'
-  sh 'vlog', expand_incdir_options(:vsim), @sources
+  sh 'vlog', expand_incdir_options(id), @sources
   sh %w[vsim -c],
     '-do', 'run -all; exit',
-    '-pli', object_file_path(:vsim),
-    SIMULATOR_ARGUMENTS[:vsim],
+    '-pli', object_file_path(id),
+    SIMULATOR_ARGUMENTS[id],
     @target
 end
 
@@ -146,13 +151,12 @@ CLEAN.include 'work', 'vsim.wlf'
 CLOBBER.include 'transcript'
 
 
-desc "Simulate with #{RubyVPI::SIMULATORS[:ncsim].name}."
-task :ncsim => :setup do
+sim_task :ncsim do |id|
   sh %w[ncverilog +access+rwc +plinowarn],
-    "+loadvpi=#{object_file_path(:ncsim)}:#{LOADER_FUNC}",
+    "+loadvpi=#{object_file_path(id)}:#{LOADER_FUNC}",
     ('+nc64bit' if @archIs64),
-    SIMULATOR_ARGUMENTS[:ncsim],
-    expand_incdir_options(:ncsim),
+    SIMULATOR_ARGUMENTS[id],
+    expand_incdir_options(id),
     @sources
 end