ruby-vpi 20.0.0 → 21.0.0

data/examples/register_file/register_file_runner.rake

@@ -7,7 +7,7 @@ TEST_LOADER = "register_file_loader.rb"
 # details) to source files and directories that contain source files.  These
 # source files will be loaded by the simulator before the simulation begins.
 SIMULATOR_SOURCES = FileList[
-  'register_file.v',
+  'register_file.v'
 ]
 
 # Command-line arguments for the simulator.  These arguments can be

data/ext/Rakefile

@@ -21,16 +21,25 @@ task :default => 'Makefile' do |t|
 end
 
 file 'Makefile' => [:swig, 'extconf.rb'] do |t|
-  ruby t.prerequisites[1], "--with-cflags=#{ENV['CFLAGS']}", "--with-ldflags=#{ENV['LDFLAGS']}"
+  cflags = "#{ENV['CFLAGS']} -g -Werror"
+
+  # detect ruby version on behalf of C extension
+  v = RUBY_VERSION.split('.')
+  until v.empty?
+    cflags << " -DHAVE_RUBY_#{v.join '_'}"
+    v.pop
+  end
+
+  ruby t.prerequisites[1], "--with-cflags=#{cflags}", "--with-ldflags=#{ENV['LDFLAGS']}"
 end
 
 CLEAN.include 'Makefile', 'mkmf.log', '*.o', "*.#{Config::CONFIG['DLEXT']}"
 
 
 desc 'Generate Ruby wrapper for VPI.'
-task :swig => 'swig_wrap.cin'
+task :swig => 'swig.cin'
 
-file 'swig_wrap.cin' => 'swig_vpi.i' do |t|
+file 'swig.cin' => 'swig_vpi.i' do |t|
   sh %w[swig -Werror -w801 -ruby -o], t.name, t.prerequisites[0]
 end
 
@@ -61,4 +70,4 @@ file 'swig_vpi.h' => 'vpi_user.h' do |t|
   end
 end
 
-CLEAN.include 'swig_wrap.cin', 'swig_vpi.h'
+CLEAN.include 'swig.cin', 'swig_vpi.h'

data/ext/binding.c

@@ -0,0 +1,22 @@
+/*
+  Copyright 2008 Suraj N. Kurapati
+  See the file named LICENSE for details.
+*/
+
+#include "binding.h"
+#include "swig.cin" // SWIG generated bindings for VPI
+
+void RubyVPI_binding_init()
+{
+    Init_VPI();
+
+    // some compilers have trouble with pointers to the va_list
+    // type.  See ext/Rakefile and the user manual for details
+    rb_define_alias(mVPI, "vpi_vprintf", "vpi_printf");
+    rb_define_alias(mVPI, "vpi_mcd_vprintf", "vpi_mcd_printf");
+}
+
+VALUE RubyVPI_binding_rubify_callback(p_cb_data aCallback)
+{
+    return SWIG_NewPointerObj(aCallback, SWIGTYPE_p_t_cb_data, 0);
+}

data/ext/binding.h

@@ -0,0 +1,29 @@
+/*
+  Copyright 2008 Suraj N. Kurapati
+  See the file named LICENSE for details.
+*/
+///\file Ruby bindings for the VPI library.
+
+#ifndef BINDING_H
+#define BINDING_H
+
+    #include "verilog.h"
+    #include <ruby.h>
+
+    ///
+    /// Initializes the Ruby bindings.
+    ///
+    /// This function must be called ONLY from the
+    /// main C process (NOT from inside a thread).
+    ///
+    /// Also, this function must be called ONLY
+    /// after RubyVPI_roobee_init() has been called.
+    ///
+    void RubyVPI_binding_init();
+
+    ///
+    /// Converts the given VPI callback structure into a Ruby value.
+    ///
+    VALUE RubyVPI_binding_rubify_callback(p_cb_data aCallback);
+
+#endif

data/ext/extconf.rb

@@ -1,24 +1,31 @@
-# Generates a makefile for buiding the extension.
+# Generates a makefile for buiding the C extension.
 #--
 # Copyright 2006 Suraj N. Kurapati
 # See the file named LICENSE for details.
 
 require 'mkmf'
 
-# check for POSIX threads library
-  hasPthread = have_library('pthread', 'pthread_create')
-
 # check for ruby library
   require 'rbconfig'
 
-  rubyLibArgs = Config::CONFIG.values.grep(/^-lruby/)
+  # possible names under which Ruby library is installed
+  rubyLibNames = Config::CONFIG.values.join(' ').
+                 scan(/-l(ruby\S*)/).flatten.uniq
+
+  # possible places where Ruby library is installed
+  rubyLibPaths = Config::CONFIG.values.join(' ').
+                 scan(/-L(\S+)/).flatten.
+                 select {|f| File.exist? f }
+
+  RUBY_FUNC = 'ruby_init'
 
-  rubyLibNames = rubyLibArgs.map {|a| a.sub /^-l/, ''}
-  rubyLibNames.unshift 'ruby' # try most common name first
-  rubyLibNames.uniq!
+  hasRuby = rubyLibNames.any? do |libName|
+    have_library(libName, RUBY_FUNC) or
 
-  hasRuby = rubyLibNames.inject(false) do |verdict, name|
-    verdict ||= have_library(name, 'ruby_init')
+    rubyLibPaths.any? do |libPath|
+      have_library(libName, RUBY_FUNC, libPath)
+    end
   end
 
-hasPthread && hasRuby && create_makefile('ruby-vpi')
+# generate the makefile
+create_makefile 'ruby-vpi' if hasRuby

data/ext/host.c

@@ -0,0 +1,75 @@
+/*
+  Copyright 2008 Suraj N. Kurapati
+  See the file named LICENSE for details.
+*/
+
+#include "host.h"
+#include "util.h"
+#include "user.h"
+#include "binding.h"
+#include <ruby.h>
+#include <stdlib.h>
+
+VALUE RubyVPI_host_gProgName;
+
+#ifdef RUBY_GLOBAL_SETUP
+RUBY_GLOBAL_SETUP
+#endif
+
+PLI_INT32 RubyVPI_host_init(p_cb_data aCallback)
+{
+    //
+    // ruby init
+    //
+
+    #ifdef RUBY_INIT_STACK
+    RubyVPI_util_debug("Host: RUBY_INIT_STACK");
+    RUBY_INIT_STACK;
+    #endif
+
+    RubyVPI_util_debug("Host: ruby_init()");
+    ruby_init();
+
+    // override Ruby's hooked handlers for $0 so that $0 can be
+    // treated as pure Ruby value (and modified without restriction)
+    RubyVPI_util_debug("Host: redefine $0 hooked variable");
+    RubyVPI_host_gProgName = rb_str_new2("ruby-vpi");
+    rb_define_variable("$0", &RubyVPI_host_gProgName);
+    rb_define_variable("$PROGRAM_NAME", &RubyVPI_host_gProgName);
+
+    RubyVPI_util_debug("Host: ruby_init_loadpath()");
+    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: Init_prelude()");
+    Init_prelude();
+    #endif
+
+
+    //
+    // VPI bindings init
+    //
+
+    RubyVPI_util_debug("Host: VPI binding init");
+    RubyVPI_binding_init();
+
+
+    //
+    // ruby thread init
+    //
+
+    RubyVPI_util_debug("Host: user_init()");
+    RubyVPI_user_init();
+}
+
+PLI_INT32 RubyVPI_host_fini(p_cb_data aCallback)
+{
+    RubyVPI_util_debug("Host: user fini");
+    RubyVPI_user_fini();
+
+    RubyVPI_util_debug("Host: ruby_finalize()");
+    ruby_finalize();
+}

data/ext/host.h

@@ -0,0 +1,17 @@
+/*
+  Copyright 2008 Suraj N. Kurapati
+  See the file named LICENSE for details.
+*/
+
+#ifndef HOST_H
+#define HOST_H
+
+    #include "verilog.h"
+
+    // should be called in vlog_startup_routines
+    PLI_INT32 RubyVPI_host_init(p_cb_data aCallback);
+
+    // should be called at end of simulation
+    PLI_INT32 RubyVPI_host_fini(p_cb_data aCallback);
+
+#endif

data/ext/main.c

@@ -1,53 +1,60 @@
 /*
-  Copyright 1999 Kazuhiro HIWADA
   Copyright 2006 Suraj N. Kurapati
   See the file named LICENSE for details.
 */
 
-#include "main.h"
-#include "relay.h"
-#include <stdlib.h>
-#include <stdio.h>
-
-
-// load the SWIG-generated Ruby interface to VPI
-#include "swig_wrap.cin"
-
-
-void main_init() {
-  ruby_init();
-  ruby_init_loadpath();
-
-  // load the VPI interface for Ruby
-    Init_VPI();
-    rb_define_module_function(mVPI, "__extension__relay_verilog", main_relay_verilog, 0);
-    rb_define_module_function(mVPI, "__extension__relay_ruby_reason", main_relay_ruby_reason, 0);
-
-    // some compilers have trouble with pointers to the va_list
-    // type.  See ext/Rakefile and the user manual for details
-    rb_define_alias(mVPI, "vpi_vprintf", "vpi_printf");
-    rb_define_alias(mVPI, "vpi_mcd_vprintf", "vpi_mcd_printf");
+#include "util.h"
+#include "verilog.h"
+#include "host.h"
+#include "user.h"
+
+///
+/// Registers a very basic VPI callback with reason and handler.
+///
+static void RubyVPI_main_register_callback(PLI_INT32 aReason, PLI_INT32 (*aHandler)(p_cb_data))
+{
+    s_cb_data call;
+
+    call.reason    = aReason;
+    call.cb_rtn    = aHandler;
+    call.obj       = 0;
+    call.time      = 0;
+    call.value     = 0;
+    call.user_data = 0;
+
+    vpi_free_object(vpi_register_cb(&call));
+}
 
+static void RubyVPI_main_init()
+{
+    RubyVPI_util_debug("Main: at vlog startup");
 
-  char* bootLoader = getenv("RUBYVPI_BOOT_LOADER");
-  char* testLoader = getenv("RUBYVPI_TEST_LOADER");
+    // commence Ruby execution at the start of the simulation
+    RubyVPI_util_debug("Main: registering BEGIN simulation callback");
+    RubyVPI_main_register_callback(cbStartOfSimulation, RubyVPI_host_init);
 
-  if (bootLoader != NULL && testLoader != NULL) {
-    ruby_script(testLoader);
-    rb_load_file(bootLoader);
-    ruby_run();
-  }
-  else {
-    common_printf("error: the RUBYVPI_BOOT_LOADER and RUBYVPI_TEST_LOADER environment variables must be defined.");
-    exit(EXIT_FAILURE);
-  }
+    // clean up this C extension at the end of the simulation
+    RubyVPI_util_debug("Main: registering END simulation callback");
+    RubyVPI_main_register_callback(cbEndOfSimulation, RubyVPI_host_fini);
 }
 
-VALUE main_relay_verilog(VALUE arSelf) {
-  relay_verilog();
-  return arSelf;
-}
-
-VALUE main_relay_ruby_reason(VALUE arSelf) {
-  return SWIG_NewPointerObj(vlog_relay_ruby_reason(), SWIGTYPE_p_t_cb_data, 0);
-}
+///
+/// Verilog simulator's bootstrap vector.  The simulator
+/// will invoke the functions in this array when it loads
+/// the shared-object file compiled from this C extension.
+///
+void (*vlog_startup_routines[])() = { RubyVPI_main_init, 0 };
+
+#if defined(PRAGMATIC_CVER) || defined(SYNOPSYS_VCS) || defined(CADENCE_NCSIM)
+    ///
+    /// Invokes each routine specified in the vlog_startup_routines array.
+    ///
+    void vlog_startup_routines_bootstrap()
+    {
+        unsigned int i;
+        for (i = 0; vlog_startup_routines[i]; i++)
+        {
+            vlog_startup_routines[i]();
+        }
+    }
+#endif

data/ext/swig_vpi.i

@@ -2,16 +2,16 @@
 
 /* Parse the header file to generate wrappers */
 %{
-#include "swig_vpi.h"
+    #include "swig_vpi.h"
 %}
 %include "swig_vpi.h"
 
-/* Allows us set the VPI callback handler in Ruby:
+/* Allow the VPI callback handler function to be set from Ruby:
 
-    data        = S_cb_data.new
-    data.cb_rtn = VPI::Vlog_relay_ruby
+    data = S_cb_data.new
+    data.cb_rtn = VPI::RubyVPI_user_resume
 */
 %{
-#include "vlog.h"
+    #include "user.h"
 %}
-%constant PLI_INT32 vlog_relay_ruby(struct t_cb_data *);
+%constant PLI_INT32 RubyVPI_user_resume(p_cb_data);

data/ext/user.c

@@ -0,0 +1,95 @@
+/*
+  Copyright 2008 Suraj N. Kurapati
+  See the file named LICENSE for details.
+*/
+
+#include "user.h"
+#include "util.h"
+#include "binding.h"
+#include <ruby.h>
+
+static VALUE RubyVPI_user_require_impl(VALUE aPath)
+{
+    return rb_require((char*)aPath);
+}
+
+static VALUE RubyVPI_user_require(char* aPath)
+{
+    int error = 0;
+    VALUE result = rb_protect(RubyVPI_user_require_impl, (VALUE)aPath, &error);
+
+    if (error)
+    {
+        RubyVPI_util_error("rb_require('%s') failed with status %d", aPath, error);
+    }
+
+    return result;
+}
+
+///
+/// Body of the ruby thread which runs the user code.
+///
+static VALUE RubyVPI_user_body(char* aUserScript)
+{
+    RubyVPI_util_debug("Ruby: BEGIN synchronized with simulator");
+    RubyVPI_user_require(aUserScript); // blocks until user script is finished
+
+    RubyVPI_util_debug("Ruby: END");
+    // don't wait for anyone to resume me anymore
+}
+
+void RubyVPI_user_init()
+{
+    // mailbox init
+    RubyVPI_util_debug("User: mailbox init");
+    RubyVPI_user_require("ruby-vpi/boot/relay");
+
+
+    // 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_util_debug("User: calling RubyVPI.attach DONE");
+
+
+    RubyVPI_util_debug("User: ruby thread is active & ran once");
+}
+
+void RubyVPI_user_fini()
+{
+    // nothing to clean up; Ruby will garbage collect everything
+}
+
+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: calling RubyVPI.resume");
+    rb_funcall(target, method, 1, call); // pass callback to user code
+
+    return 0;
+}