ruby-vpi 21.0.0 → 21.1.0

data/ext/Rakefile

@@ -1,9 +1,13 @@
 # Build file for the native C extension.
 #
 # = Environment variables
-# CFLAGS::    Arguments to the compiler.
-# LDFLAGS::   Arguments to the linker.
-# SIMULATOR:: ID of the simulator.
+#
+# CFLAGS        :: Override the default options passed to the compiler.
+# CFLAGS_EXTRA  :: Provide additional options for the compiler.
+# LDFLAGS       :: Override the default options passed to the linker.
+# LDFLAGS_EXTRA :: Provide additional options for the linker.
+# SIMULATOR     :: ID of the simulator.
+#
 #--
 # Copyright 2006 Suraj N. Kurapati
 # See the file named LICENSE for details.
@@ -21,16 +25,17 @@ task :default => 'Makefile' do |t|
 end
 
 file 'Makefile' => [:swig, 'extconf.rb'] do |t|
-  cflags = "#{ENV['CFLAGS']} -g -Werror"
+  args = []
+
+  if flags = ENV['CFLAGS']
+    args << "--with-cflags=#{flags}"
+  end
 
-  # detect ruby version on behalf of C extension
-  v = RUBY_VERSION.split('.')
-  until v.empty?
-    cflags << " -DHAVE_RUBY_#{v.join '_'}"
-    v.pop
+  if flags = ENV['LDFLAGS']
+    args << "--with-ldflags=#{flags}"
   end
 
-  ruby t.prerequisites[1], "--with-cflags=#{cflags}", "--with-ldflags=#{ENV['LDFLAGS']}"
+  ruby t.prerequisites[1], *args
 end
 
 CLEAN.include 'Makefile', 'mkmf.log', '*.o', "*.#{Config::CONFIG['DLEXT']}"

data/ext/extconf.rb

@@ -1,4 +1,10 @@
 # Generates a makefile for buiding the C extension.
+#
+# = Environment variables
+#
+# CFLAGS_EXTRA  :: Provide additional options for the compiler.
+# LDFLAGS_EXTRA :: Provide additional options for the linker.
+#
 #--
 # Copyright 2006 Suraj N. Kurapati
 # See the file named LICENSE for details.
@@ -28,4 +34,27 @@ require 'mkmf'
   end
 
 # generate the makefile
-create_makefile 'ruby-vpi' if hasRuby
+if hasRuby
+  # apply additional arguments for compiler and linker
+  if flags = ENV['CFLAGS_EXTRA']
+    $CFLAGS << " #{flags}"
+  end
+
+  if flags = ENV['LDFLAGS_EXTRA']
+    $LDFLAGS << " #{flags}"
+  end
+
+  $CFLAGS << ' -Wall'
+
+  # disable optimization when debugging
+  $CFLAGS << ' -g -O0' if $CFLAGS =~ /-DDEBUG\b/
+
+  # detect ruby version on behalf of C extension
+  v = RUBY_VERSION.split('.')
+  until v.empty?
+    $CFLAGS << " -DHAVE_RUBY_#{v.join '_'}"
+    v.pop
+  end
+
+  create_makefile 'ruby-vpi'
+end

data/ext/host.c

@@ -13,7 +13,7 @@
 VALUE RubyVPI_host_gProgName;
 
 #ifdef RUBY_GLOBAL_SETUP
-RUBY_GLOBAL_SETUP
+    RUBY_GLOBAL_SETUP
 #endif
 
 PLI_INT32 RubyVPI_host_init(p_cb_data aCallback)
@@ -23,8 +23,8 @@ PLI_INT32 RubyVPI_host_init(p_cb_data aCallback)
     //
 
     #ifdef RUBY_INIT_STACK
-    RubyVPI_util_debug("Host: RUBY_INIT_STACK");
-    RUBY_INIT_STACK;
+        RubyVPI_util_debug("Host: RUBY_INIT_STACK");
+        RUBY_INIT_STACK;
     #endif
 
     RubyVPI_util_debug("Host: ruby_init()");
@@ -41,11 +41,11 @@ PLI_INT32 RubyVPI_host_init(p_cb_data aCallback)
     ruby_init_loadpath();
 
     #ifdef HAVE_RUBY_1_9
-    RubyVPI_util_debug("Host: ruby_init_gems(Qtrue)");
-    rb_const_set(rb_define_module("Gem"), rb_intern("Enable"), Qtrue);
+        RubyVPI_util_debug("Host: ruby_init_gems(Qtrue)");
+        rb_const_set(rb_define_module("Gem"), rb_intern("Enable"), Qtrue);
 
-    RubyVPI_util_debug("Host: Init_prelude()");
-    Init_prelude();
+        RubyVPI_util_debug("Host: Init_prelude()");
+        Init_prelude();
     #endif
 
 
@@ -63,6 +63,8 @@ PLI_INT32 RubyVPI_host_init(p_cb_data aCallback)
 
     RubyVPI_util_debug("Host: user_init()");
     RubyVPI_user_init();
+
+    return 0;
 }
 
 PLI_INT32 RubyVPI_host_fini(p_cb_data aCallback)
@@ -72,4 +74,6 @@ PLI_INT32 RubyVPI_host_fini(p_cb_data aCallback)
 
     RubyVPI_util_debug("Host: ruby_finalize()");
     ruby_finalize();
+
+    return 0;
 }

data/ext/user.c

@@ -36,8 +36,13 @@ static VALUE RubyVPI_user_body(char* aUserScript)
 
     RubyVPI_util_debug("Ruby: END");
     // don't wait for anyone to resume me anymore
+
+    return Qnil;
 }
 
+static VALUE RubyVPI_user__module_RubyVPI = Qnil;
+static ID RubyVPI_user__symbol_resume = 0;
+
 void RubyVPI_user_init()
 {
     // mailbox init
@@ -47,49 +52,36 @@ void RubyVPI_user_init()
 
     // ruby thread init
     RubyVPI_util_debug("User: ruby thread init");
-
     rb_thread_create(RubyVPI_user_body, "ruby-vpi/boot/loader");
 
 
     // wait for thread to pause
     RubyVPI_util_debug("User: calling RubyVPI.attach");
 
-    VALUE target = rb_const_get(rb_cObject, rb_intern("RubyVPI"));
-    ID method = rb_intern("attach");
-    rb_funcall(target, method, 0);
+    RubyVPI_user__module_RubyVPI = rb_const_get(rb_cObject, rb_intern("RubyVPI"));
+    rb_funcall(RubyVPI_user__module_RubyVPI, rb_intern("attach"), 0);
 
     RubyVPI_util_debug("User: calling RubyVPI.attach DONE");
 
 
     RubyVPI_util_debug("User: ruby thread is active & ran once");
+    RubyVPI_user__symbol_resume = rb_intern("resume");
 }
 
 void RubyVPI_user_fini()
 {
-    // nothing to clean up; Ruby will garbage collect everything
+    RubyVPI_user__module_RubyVPI = Qnil;
+    // Ruby will garbage collect everything else
 }
 
 PLI_INT32 RubyVPI_user_resume(p_cb_data aCallback)
 {
     RubyVPI_util_debug("Main: callback = %p", aCallback);
-
-    if (aCallback)
-    {
-        RubyVPI_util_debug("Main: callback.user_data = %p", aCallback->user_data);
-    }
-    else
-    {
-        RubyVPI_util_debug("Main: callback is NULL");
-    }
-
-    RubyVPI_util_debug("Main: ruby callback for %p =>", aCallback);
-    VALUE call = RubyVPI_binding_rubify_callback(aCallback);
-
-    VALUE target = rb_const_get(rb_cObject, rb_intern("RubyVPI"));
-    ID method = rb_intern("resume");
+    RubyVPI_util_debug("Main: callback.user_data = %p", aCallback ? aCallback->user_data : 0);
 
     RubyVPI_util_debug("Main: calling RubyVPI.resume");
-    rb_funcall(target, method, 1, call); // pass callback to user code
+    // pass VPI callback to user code as Ruby object
+    rb_funcall(RubyVPI_user__module_RubyVPI, RubyVPI_user__symbol_resume, 1, RubyVPI_binding_rubify_callback(aCallback));
 
     return 0;
 }

data/lib/ruby-vpi.rb

@@ -6,9 +6,9 @@
 module RubyVPI
   Project = {
     :name    => 'ruby-vpi',
-    :version => '21.0.0',
-    :release => '2008-06-08',
-    :website => "http://ruby-vpi.rubyforge.org",
+    :version => '21.1.0',
+    :release => '2008-08-02',
+    :website => 'http://ruby-vpi.rubyforge.org',
     :home    => File.expand_path(File.join(File.dirname(__FILE__), '..'))
   }
 

data/lib/ruby-vpi/boot/loader.rb

@@ -141,11 +141,11 @@ begin
       include VPI
     end
 
-  # load the user-defined test loader
-    RubyVPI::Scheduler.start
+  RubyVPI::Scheduler.run do
+    # load the user-defined test loader
     require ENV['RUBYVPI_TEST_LOADER']
 
-  # simulate at_exit handler invocation
+    # simulate at_exit handler invocation
     Kernel.__RubyVPI__simulate_exit
 
     # restore original at_exit handler
@@ -153,6 +153,7 @@ begin
       alias at_exit __RubyVPI__orig_at_exit
       undef __RubyVPI__simulate_exit
     end
+  end
 
   RubyVPI.detach
 

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

@@ -1,4 +1,4 @@
-# Concurrent processes.
+# Concurrent processes (coroutines).
 #--
 # Copyright 2007 Suraj N. Kurapati
 # See the file named LICENSE for details.
@@ -6,147 +6,159 @@
 Thread.abort_on_exception = true
 
 require 'singleton'
+require 'generator'
 
 module RubyVPI
   class SchedulerClass #:nodoc:
     include Singleton
 
+    def initialize
+      @writes = Hash.new {|h,k| h[k] = []}
+      @writes_lock = Mutex.new
 
-    Task = Struct.new(:thread, :state)
+      # for coroutines in Ruby-based prototypes of Verilog hardware
+      @routines = []
+      @routines_lock = Mutex.new
+      @current_routine = nil
 
-    class Task #:nodoc:
-      def run
-        self.state = :run
-        self.thread.wakeup
-      end
+      @current_time = 0
 
-      def stop
-        self.state = :wait
-        Thread.stop
+      # allow "initial" blocks in Verilog code of DUT to take effect
+      if @current_time.zero?
+        unless RubyVPI::USE_PROTOTYPE
+          advance_to_read_only_slot
+        end
       end
+    end
+
+    # Returns the current simulation time, as tracked by the scheduler.
+    attr_reader :current_time
 
-      def stop?
-        self.thread.stop? and self.state == :wait
+    # Registers a new routine with the scheduler.  The given block is the body
+    # of the routine and the given arguments are passed directly to the block.
+    def register_routine *aRoutineArgs, &aRoutineBody
+      @routines_lock.synchronize do
+        @routines << Routine.new(*aRoutineArgs, &aRoutineBody)
       end
     end
 
+    # Makes the current routine wait for the
+    # scheduler to arrive in the next time step.
+    def pause_current_routine
+      @current_routine.pause
+    end
 
-    def initialize
-      @thread2task = { Thread.current => Task.new(Thread.current, :run) }
-      @thread2task_soft = @thread2task.dup  # software threads
-      @thread2task_hard = {} # hardware threads (Ruby prototype of DUT)
-      @thread2task_lock = Mutex.new
+    # Runs the scheduler until there are no more routines to be scheduled.
+    def run &aRoutineBody
+      main = Routine.new(&aRoutineBody)
+
+      until main.done?
+        # run software in current time step
+        resume_routine main
 
-      # base case: hardware runs first before any software does at startup
-        @time = 0
+        Edge.refresh_cache
 
+        # go to time slot where writing is permitted
+        # before applying captured write operations
         unless RubyVPI::USE_PROTOTYPE
-          Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
+          if RubyVPI::USE_SIMULATOR == :vsim
+            Callback.relay_verilog(VPI::CbAfterDelay, 0)
+          else
+            Callback.relay_verilog(VPI::CbAfterDelay, 1)
+          end
         end
 
-      @scheduler = Thread.new do
-        # pause because boot loader is not fully initialized yet
-        Thread.stop
-
-        loop do
-          # run software in current time step
-            run_tasks @thread2task_soft, 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
+        apply_writes
 
-            flush_writes
+        # run hardware in next time step
+        @current_time += 1
 
-          # run hardware in next time step
-            @time += 1
+        if RubyVPI::USE_PROTOTYPE
+          @routines_lock.synchronize do
+            @routines.reject! {|r| r.done? }
 
-            if RubyVPI::USE_PROTOTYPE
-              run_tasks @thread2task_hard, false
-              flush_writes
-            else
-              Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
+            @routines.each do |r|
+              resume_routine r
             end
+          end
+
+          apply_writes
+        else
+          advance_to_read_only_slot
         end
       end
+    end
 
-
-      @handle2write = Hash.new {|h,k| h[k] = []}
-      @handle2write_lock = Mutex.new
+    # Captures the given write operation so it
+    # can be flushed later, at the correct time.
+    def capture_write aHandle, *aArgs
+      @writes_lock.synchronize do
+        @writes[aHandle] << Write.new(Thread.current, caller, aArgs)
+      end
     end
 
-    def current_time
-      @time
+    private
+
+    def advance_to_read_only_slot
+      Callback.relay_verilog(VPI::CbReadOnlySynch, 0)
     end
 
-    def start
-      @scheduler.wakeup
+    # Resumes the given routine while marking it as the current one.
+    def resume_routine aRoutine
+      @current_routine = aRoutine
+      @current_routine.resume
+      @current_routine = nil
     end
 
-    # Registers the calling thread with the scheduler.
-    def attach
-      key = Thread.current
+    # Represents Verilog's "process block" construct (a coroutine or concurrent
+    # process), which is used as the body of an "initial" or "forever" block.
+    class Routine
+      def initialize *aLogicArgs, &aLogicBody
+        raise ArgumentError unless block_given?
 
-      hash =
-        if caller.grep(/_proto\.rb/).empty?
-          @thread2task_soft
-        else
-          @thread2task_hard
+        @gen = Generator.new do |@ctl|
+          pause # until we are ready to begin
+          aLogicBody.call(*aLogicArgs)
         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_hard.delete key
-        @thread2task_soft.delete key
+      # Pauses the execution of this process block.
+      #
+      # Must be called from *inside* the logic of this process block.
+      def pause
+        @ctl.yield nil
       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]
+      # Returns true if this process block is
+      # currently paused and can thus be resumed.
+      #
+      # Must be called from *outside* the logic of this process block.
+      def pause?
+        @gen.next?
       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).'
+      # Resumes the execution of this process block.
+      #
+      # Must be called from *outside* the logic of this process block.
+      def resume
+        @gen.next
       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)
+      # Returns true if this process block is
+      # finished (it cannot be resumed anymore).
+      #
+      # Must be called from *outside* the logic of this process block.
+      def done?
+        not pause?
       end
     end
 
-    private
+    Write = Struct.new :thread, :trace, :args
 
     # Flushes all captured writes.
-    def flush_writes
-      @handle2write_lock.synchronize do
-        @handle2write.each_pair do |handle, writes|
+    def apply_writes
+      @writes_lock.synchronize do
+        @writes.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}"
@@ -161,27 +173,14 @@ module RubyVPI
         end
       end
     end
-
-    def run_tasks aHash, aExitWhenEmpty
-      @thread2task_lock.synchronize do
-        tasks = aHash.values
-        tasks.each {|t| t.run}
-
-        if aExitWhenEmpty && tasks.empty?
-          Thread.exit
-        end
-      end
-
-      until @thread2task_lock.synchronize { aHash.values.all? {|t| t.stop? } }
-        Thread.pass
-      end
-    end
   end
 
   Scheduler = SchedulerClass.instance
 end
 
 module VPI
+  # intercept all writes to VPI handles so that
+  # they can be applied later by the scheduler
   alias_method :__scheduler__vpi_put_value, :vpi_put_value
   module_function :__scheduler__vpi_put_value
 
@@ -197,8 +196,7 @@ module VPI
 
   # 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 }
+    aNumTimeSteps.times { RubyVPI::Scheduler.pause_current_routine }
   end
 
   alias wait advance_time
@@ -206,15 +204,8 @@ module VPI
 
   # 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
+  def process *aBlockArgs, &aBlock
+    RubyVPI::Scheduler.register_routine(*aBlockArgs, &aBlock)
   end
 
   # Wraps the given block inside an infinite loop and executes it
@@ -226,7 +217,7 @@ module VPI
         aBlock.call(*aBlockArgs)
         finishTime = VPI.current_time
 
-        VPI.advance_time unless finishTime > startTime
+        advance_time unless finishTime > startTime
       end
     end
   end