HDLRuby 3.2.0 → 3.3.0

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -6,9 +6,16 @@
 #include <string.h>
 #include <limits.h>
 
+#if defined(_WIN32) || defined(_WIN64)
+#include <windows.h>
+#include <direct.h>
+#else
+#include <dlfcn.h>
+#endif
+
 #include <ruby.h>
-#include "extconf.h"
 
+#include "extconf.h"
 #include "hruby_sim.h"
 
 // #if defined(_WIN32) || defined(_WIN64)
@@ -72,7 +79,10 @@
 // rcsim_wrapper(RefIndex);
 // rcsim_wrapper(RefRange);
 
-static VALUE RCSimPointer;
+static VALUE RCSimPointer;      // The C pointer type for Ruby.
+static VALUE RCSimCinterface;   // The RCSim Ruby module for C.
+static VALUE RCSimCports;       // The RCSim table of C ports.
+// static VALUE RubyHDL;           // The interface for Ruby programs.
 
 #define rcsim_to_value(TYPE,POINTER,VALUE) \
     (VALUE) = Data_Wrap_Struct(RCSimPointer, 0, 0, (POINTER))
@@ -376,6 +386,123 @@ VALUE rcsim_make_systemI(VALUE mod, VALUE name, VALUE systemT) {
 }
 
 
+void ruby_function_wrap(Code);
+
+/* Creating a system code C object. 
+ * Note: HDLRuby Code object are actually refactored to Program object,
+ *       but the low-level simulation still use Code as data structure.
+ *       Hence, it may change in the future. */
+VALUE rcsim_make_code(VALUE mod, VALUE lang, VALUE funcname) {
+    // printf("rcsim_make_code\n");
+    /* Allocates the code. */
+    Code code = (Code)malloc(sizeof(CodeS));
+    // printf("code=%p\n",code);
+    /* Set it up. */
+    code->kind  = CODE;
+    code->owner = NULL;
+    code->name = strdup(StringValueCStr(funcname));
+    // printf("code->name=%p\n",code->name);
+    code->num_events = 0;
+    code->events = NULL;
+    code->function = NULL;
+    char* langStr = StringValueCStr(lang);
+    if(strncmp(langStr,"ruby",4) == 0) {
+        /* Ruby function. */
+        code->function = ruby_function_wrap;
+    } else if (strncmp(langStr,"c",1) == 0) {
+        /* C or C-compatible dynamically compiled code: it will be loaded
+         * afterward */
+        code->function = NULL;
+    } else {
+        /* Other language function. */
+        fprintf(stderr,"Unsupported language.");
+        exit(-1);
+    }
+    code->enabled = 0;
+    code->activated = 0;
+    /* Returns the C code embedded into a ruby VALUE. */
+    VALUE res;
+    rcsim_to_value(CodeS,code,res);
+    return res;
+}
+
+
+
+
+#if defined(_WIN32) || defined(_WIN64)
+/** Loads a C program dynamic library (called from HDLRuby) for a code. */
+VALUE rcsim_load_c(VALUE mod, VALUE codeV, VALUE libnameV, VALUE funcnameV) {
+    char* libname;
+    char* funcname;
+    Code code;
+    HINSTANCE handle;
+
+    libname  = StringValueCStr(libnameV);
+    funcname = StringValueCStr(funcnameV);
+
+    char path[1024];
+
+    if (getcwd(path, sizeof(path)) != NULL) {
+        printf("Current working directory: %s\n", path);
+    } else {
+        perror("getcwd error");
+        return 1;
+    }
+
+    if(strlen(path) + strlen(libname) >= 1023) {
+        fprintf(stderr,"Path too long for loading c program.\n");
+    }
+    strcat(path,"/");
+    strcat(path,libname);
+    // printf("Loading c program at: %s\n",path);
+   
+    /* Get the code. */ 
+    value_to_rcsim(CodeS,codeV,code);
+    /* Load the library. */
+    handle = LoadLibrary(TEXT(path));
+    if (handle == NULL) {
+        fprintf(stderr,"Unable to open program library at: %s\n",path);
+        DWORD dwError = GetLastError();
+        fprintf(stderr,"LoadLibrary failed with error code %ld\n", dwError);
+        exit(-1);
+    }
+    code->function = GetProcAddress(handle,funcname);
+    if (code->function == NULL) {
+        fprintf(stderr,"Unable to get function: %s\n",code->name);
+        exit(-1);
+    }
+    return codeV;
+}
+#else
+/** Loads a C program dynamic library (called from HDLRuby) for a code. */
+VALUE rcsim_load_c(VALUE mod, VALUE codeV, VALUE libnameV, VALUE funcnameV) {
+    char* libname;
+    char* funcname;
+    Code code;
+    void* handle;
+
+    libname  = StringValueCStr(libnameV);
+    funcname = StringValueCStr(funcnameV);
+   
+    /* Get the code. */ 
+    value_to_rcsim(CodeS,codeV,code);
+    /* Load the library. */
+    handle = dlopen(libname,RTLD_NOW | RTLD_GLOBAL);
+    if (handle == NULL) {
+        fprintf(stderr,"Unable to open program: %s\n",dlerror());
+        exit(-1);
+    }
+    code->function = dlsym(handle,funcname);
+    if (code->function == NULL) {
+        fprintf(stderr,"Unable to get function: %s\n",code->name);
+        exit(-1);
+    }
+    return codeV;
+}
+#endif
+
+
+
 /* Creating a transmit C object. */
 VALUE rcsim_make_transmit(VALUE mod, VALUE left, VALUE right) {
     // printf("rcsim_make_transmit\n");
@@ -955,6 +1082,30 @@ VALUE rcsim_add_scope_systemIs(VALUE mod, VALUE scopeV, VALUE sysVs) {
     return scopeV;
 }
 
+/* Adds codes to a C scope. */
+VALUE rcsim_add_scope_codes(VALUE mod, VALUE scopeV, VALUE codeVs) {
+    /* Get the C scope from the Ruby value. */
+    Scope scope;
+    value_to_rcsim(ScopeS,scopeV,scope);
+    // printf("rcsim_add_scope_codes with scope=%p\n",scope);
+    /* Prepare the size for the codes. */
+    long num = RARRAY_LEN(codeVs);
+    long old_num = scope->num_codes;
+    scope->num_codes += num;
+    // printf("first scope->codes=%p\n",scope->codes); fflush(stdout);
+    scope->codes = realloc(scope->codes,
+                            sizeof(Code[scope->num_codes]));
+    // printf("now scope->codes=%p\n",scope->codes); fflush(stdout);
+    // printf("access test: %p\n",scope->codes[0]); fflush(stdout);
+    /* Get and add the codes from the Ruby value. */
+    for(long i=0; i< num; ++i) {
+        Code code;
+        value_to_rcsim(CodeS,rb_ary_entry(codeVs,i),code);
+        scope->codes[old_num + i] = code;
+    }
+    return scopeV;
+}
+
 /* Adds sub scopes to a C scope. */
 VALUE rcsim_add_scope_scopes(VALUE mod, VALUE scopeV, VALUE scpVs) {
     /* Get the C scope from the Ruby value. */
@@ -1051,6 +1202,53 @@ VALUE rcsim_add_behavior_events(VALUE mod, VALUE behaviorV, VALUE eventVs) {
     return behaviorV;
 }
 
+
+/* Adds events to a C code. */
+VALUE rcsim_add_code_events(VALUE mod, VALUE codeV, VALUE eventVs) {
+    /* Get the C code from the Ruby value. */
+    Code code;
+    value_to_rcsim(CodeS,codeV,code);
+    // printf("rcsim_add_codee_events with code=%p\n",code);
+    /* Prepare the size for the events. */
+    long num = RARRAY_LEN(eventVs);
+    long old_num = code->num_events;
+    code->num_events += num;
+    // printf("first code->events=%p\n",code->events); fflush(stdout);
+    code->events = realloc(code->events,
+                               sizeof(Event[code->num_events]));
+    // printf("now code->events=%p\n",code->events); fflush(stdout);
+    // printf("access test: %p\n",code->events[0]); fflush(stdout);
+    /* Get and add the events from the Ruby value. */
+    for(long i=0; i< num; ++i) {
+        Event event;
+        value_to_rcsim(EventS,rb_ary_entry(eventVs,i),event);
+        code->events[old_num + i] = event;
+        /* Update the signal of the event to say it activates the code. */
+        SignalI sig = event->signal;
+        switch(event->edge) {
+            case ANYEDGE:
+                sig->num_any++;
+                sig->any = realloc(sig->any,sizeof(Object[sig->num_any]));
+                sig->any[sig->num_any-1] = (Object)code;
+                break;
+            case POSEDGE:
+                sig->num_pos++;
+                sig->pos = realloc(sig->pos,sizeof(Object[sig->num_pos]));
+                sig->pos[sig->num_pos-1] = (Object)code;
+                break;
+            case NEGEDGE:
+                sig->num_neg++;
+                sig->neg = realloc(sig->neg,sizeof(Object[sig->num_neg]));
+                sig->neg[sig->num_neg-1] = (Object)code;
+                break;
+            default:
+                perror("Invalid value for an edge.");
+        }
+    }
+    return codeV;
+}
+
+
 /* Adds alternate system types to a C system instance. */
 VALUE rcsim_add_systemI_systemTs(VALUE mod, VALUE systemIV, VALUE sysVs) {
     /* Get the C systemI from the Ruby value. */
@@ -1381,7 +1579,10 @@ VALUE rcsim_set_behavior_block(VALUE mod, VALUE behaviorV, VALUE blockV) {
     return behaviorV;
 }
 
-/** Sets the value for a C signal. */
+/** Sets the value for a C signal.
+ *  NOTE: for initialization only (the simulator events are not updated),
+ *  otherwise, please use rcsim_transmit_to_signal or
+ *  rc_sim_transmit_to_signal_seq. */
 VALUE rcsim_set_signal_value(VALUE mod, VALUE signalV, VALUE exprV) {
     /* Get the C signal from the Ruby value. */
     SignalI signal;
@@ -1400,6 +1601,127 @@ VALUE rcsim_set_signal_value(VALUE mod, VALUE signalV, VALUE exprV) {
     return signalV;
 }
 
+/** Gets the value of a C signal. */
+VALUE rcsim_get_signal_value(VALUE mod, VALUE signalV) {
+    VALUE res;
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_get_signal_value for signal=%s\n",signal->name);
+    /* Returns the current value. */
+    rcsim_to_value(ValueS,signal->c_value,res);
+    return res; 
+}
+
+/** Transmit a value to a signal in a non-blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_to_signal(VALUE mod, VALUE signalV, VALUE exprV) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_set_signal_value for signal=%s\n",signal->name);
+    /* Get the C expression from the Ruby value. */
+    Expression expr;
+    value_to_rcsim(ExpressionS,exprV,expr);
+    /* Compute the value from it. */
+    Value value = get_value();
+    value = calc_expression(expr,value);
+    /* Transmit it. */
+    transmit_to_signal(value, signal);
+    /* End, return the transmitted expression. */
+    return exprV;
+}
+
+/** Transmit a value to a signal in a blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_to_signal_seq(VALUE mod, VALUE signalV, VALUE exprV) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_set_signal_value for signal=%s\n",signal->name);
+    /* Get the C expression from the Ruby value. */
+    Expression expr;
+    value_to_rcsim(ExpressionS,exprV,expr);
+    /* Compute the value from it. */
+    Value value = get_value();
+    value = calc_expression(expr,value);
+    /* Transmit it. */
+    transmit_to_signal_seq(value, signal);
+    /* End, return the transmitted expression. */
+    return exprV;
+}
+
+
+
+
+/** Gets the value of a C signal as a Ruby fixnum.
+ *  Sets 0 if the value contains x or z bits. */
+VALUE rcsim_get_signal_fixnum(VALUE mod, VALUE signalV) {
+    Value value;
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    // printf("rc_sim_get_signal_fixnum for signal=%s\n",signal->name);
+    /* Get the value from the signal. */
+    value = signal->c_value;
+    // /* Is the value a numeric? */
+    // if(value->numeric == 1) {
+    //     /* Yes, return it as a Ruby fixnum. */
+    //     return LONG2FIX(value->data_int);
+    // } else {
+    //     /* No, return 0. */
+    //     return LONG2FIX(0);
+    // }
+    return LONG2FIX(value2integer(value));
+}
+
+/** Transmit a Ruby fixnum to a signal in a non-blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_fixnum_to_signal(VALUE mod, VALUE signalV, VALUE valR) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    /* Compute the simualtion value from valR. */
+    Value value = get_value();
+    value->type = signal->type;
+    value->numeric = 1;
+    value->data_int = FIX2LONG(valR);
+    /* Transmit it. */
+    transmit_to_signal(value, signal);
+    /* End, return the transmitted expression. */
+    return valR;
+}
+
+/** Transmit a Ruby fixnum to a signal in a non-blocking fashion.
+ * NOTE: the simulator events are updated. */
+VALUE rcsim_transmit_fixnum_to_signal_seq(VALUE mod, VALUE signalV, VALUE valR) {
+    /* Get the C signal from the Ruby value. */
+    SignalI signal;
+    value_to_rcsim(SignalIS,signalV,signal);
+    /* Compute the simualtion value from valR. */
+    Value value = get_value();
+    value->type = signal->type;
+    value->numeric = 1;
+    value->data_int = FIX2LONG(valR);
+    /* Transmit it. */
+    transmit_to_signal_seq(value, signal);
+    /* End, return the transmitted expression. */
+    return valR;
+}
+
+
+// /** Execute a behavior. */
+// VALUE rcsim_execute_behavior(VALUE mod, VALUE behaviorV) {
+//     /* Get the behavior. */
+//     Behavior behavior;
+//     value_to_rcsim(BehaviorS,behaviorV,behavior);
+//     /* Execute the behavior. */
+//     execute_statement((Statement)(behavior->block),0,behavior);
+//     /* Returns the behavior. */
+//     return behaviorV;
+// }
+
+
 
 /** Starts the C-Ruby hybrid simulation.
  *  @param systemTV the top system type. 
@@ -1432,6 +1754,67 @@ VALUE rcsim_main(VALUE mod, VALUE systemTV, VALUE name, VALUE outmodeV) {
 }
 
 
+/** The wrapper for calling Ruby functions from the simulator. */
+void ruby_function_wrap(Code code) {
+    /* Convert the C code object to a Ruby VALUE. */
+    VALUE codeR;
+    rcsim_to_value(CodeS,code,codeR);
+    /* Call the ruby function launcher. */
+    rb_funcall(rb_cObject,rb_intern(code->name),0,Qnil);
+}
+
+
+/** The C interface. */
+
+#if defined(_WIN32) || defined(_WIN64)
+__declspec(dllexport) SignalI c_get_port(char* name);
+__declspec(dllexport) unsigned long long c_read_port(SignalI port);
+__declspec(dllexport) unsigned long long c_write_port(SignalI port, unsigned long long val);
+#endif
+
+
+/** The wrapper for getting an interface port for C software. */
+SignalI c_get_port(char* name) {
+    /* Get the C signal as a value. */
+    VALUE sigV = rb_hash_aref(RCSimCports,ID2SYM(rb_intern(name)));
+    /* Was there a signal? */
+    if (!NIL_P(sigV)) {
+        /* Yes, return it. */
+        SignalI sig;
+        value_to_rcsim(SignalIS,sigV,sig);
+        return sig;
+    } else {
+        /* No return NULL. */
+        return NULL;
+    }
+}
+
+/** The wrapper for getting a value from a port. */
+unsigned long long c_read_port(SignalI port) {
+    Value val = port->c_value;
+    if (val->numeric == 1) {
+        /* There is a defined value, return it. */
+        return val->data_int;
+    } else {
+        /* The value is undefined, return 0. */
+        return 0;
+    }
+}
+
+/** The wrapper for setting a value to a port. */
+unsigned long long c_write_port(SignalI port, unsigned long long val) {
+    /* Generate the value. */
+    Value value = get_value();
+    value->numeric = 1;
+    value->data_int = val;
+    /* Transmit it. */
+    transmit_to_signal_seq(value, port);
+    /* Returns the transmitted value. */
+    return val;
+}
+
+
+/* The simulator creation. */
 
 
 /** The initialization of the C-part of the C-Ruby hybrid HDLRuby simulator. */
@@ -1440,6 +1823,12 @@ void Init_hruby_sim() {
     make_sym_IDs();
     /* Create the module for C-Ruby interface. */
     VALUE mod = rb_define_module("RCSimCinterface");
+    RCSimCinterface = mod;
+
+    /* Create the table of C ports and add it to the C-Ruby interface. */
+    RCSimCports = rb_hash_new();
+    rb_define_const(mod,"CPorts",RCSimCports);
+
 
     /* Create the class that wraps C pointers. */
     RCSimPointer = rb_define_class("RCSimPointer",rb_cObject);
@@ -1458,6 +1847,8 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_make_event",rcsim_make_event,2);
     rb_define_singleton_method(mod,"rcsim_make_signal",rcsim_make_signal,2);
     rb_define_singleton_method(mod,"rcsim_make_systemI",rcsim_make_systemI,2);
+    rb_define_singleton_method(mod,"rcsim_make_code",rcsim_make_code,2);
+    rb_define_singleton_method(mod,"rcsim_load_c",rcsim_load_c,3);
     rb_define_singleton_method(mod,"rcsim_make_transmit",rcsim_make_transmit,2);
     rb_define_singleton_method(mod,"rcsim_make_print",rcsim_make_print,0);
     rb_define_singleton_method(mod,"rcsim_make_timeWait",rcsim_make_timeWait,2);
@@ -1484,8 +1875,10 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_add_scope_inners",rcsim_add_scope_inners,2);
     rb_define_singleton_method(mod,"rcsim_add_scope_behaviors",rcsim_add_scope_behaviors,2);
     rb_define_singleton_method(mod,"rcsim_add_scope_systemIs",rcsim_add_scope_systemIs,2);
+    rb_define_singleton_method(mod,"rcsim_add_scope_codes",rcsim_add_scope_codes,2);
     rb_define_singleton_method(mod,"rcsim_add_scope_scopes",rcsim_add_scope_scopes,2);
     rb_define_singleton_method(mod,"rcsim_add_behavior_events",rcsim_add_behavior_events,2);
+    rb_define_singleton_method(mod,"rcsim_add_code_events",rcsim_add_code_events,2);
     rb_define_singleton_method(mod,"rcsim_add_systemI_systemTs",rcsim_add_systemI_systemTs,2);
     rb_define_singleton_method(mod,"rcsim_add_signal_signals",rcsim_add_signal_signals,2);
     rb_define_singleton_method(mod,"rcsim_add_print_args",rcsim_add_print_args,2);
@@ -1503,6 +1896,10 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_set_signal_value",rcsim_set_signal_value,2);
     /* Starting the simulation. */
     rb_define_singleton_method(mod,"rcsim_main",rcsim_main,3);
+    /* The Ruby software interface. */
+    rb_define_singleton_method(mod,"rcsim_get_signal_fixnum",rcsim_get_signal_fixnum,1);
+    rb_define_singleton_method(mod,"rcsim_transmit_fixnum_to_signal_seq",rcsim_transmit_fixnum_to_signal_seq,2);
+    // rb_define_singleton_method(mod,"rcsim_execute_behavior",rcsim_execute_behavior,1);
 
 }
 

data/ext/hruby_sim/hruby_sim.h

@@ -605,9 +605,10 @@ typedef struct CodeS_ {
     Kind kind;          /* The kind of object. */
     Object owner;       /* The owner if any. */
 
+    char* name;         /* The name of the called function. */
     int num_events;     /* The number of events. */
     Event* events;      /* The events of the behavior. */
-    void (*function)(); /* The function to execute for the code. */
+    void (*function)(Code); /* The function to execute for the code. */
 
     int enabled;        /* Tells if the behavior is enabled or not. */
 

data/ext/hruby_sim/hruby_sim_calc.c

@@ -237,7 +237,7 @@ Value make_value(Type type, int numeric) {
 /** Make the size of a value able to store size ints.
  *  @note The content of the value is lost!
  *  @note do not change the type of the value, only its capacity.
- *  @praam value the value to change
+ *  @param value the value to change
  *  @param size the size to match */
 void resize_value(Value value, unsigned long long size) {
     if (value->capacity < size) {

data/ext/hruby_sim/hruby_sim_core.c

@@ -331,7 +331,8 @@ void hruby_sim_update_signals() {
                 /* Is the code really activated? */
                 if (cod->enabled && cod->activated) {
                     /* Yes, execute it. */
-                    cod->function();
+                    // cod->function();
+                    cod->function(cod); // NOTE: cod argument is required for identification.
                     /* And deactivate it. */
                     cod->activated = 0;
                 }
@@ -368,15 +369,24 @@ void hruby_sim_advance_time() {
  *  @param status the enable status. */
 static void set_enable_scope(Scope scope, int status) {
     int i;
-    int num_beh = scope->num_behaviors;
-    Behavior*  behs = scope->behaviors;
-    int num_scp = scope->num_scopes;
-    Scope* scps = scope->scopes;
+
+    int num_beh    = scope->num_behaviors;
+    Behavior* behs = scope->behaviors;
+
+    int num_cod    = scope->num_codes;
+    Code* cods     = scope->codes;
+    
+    int num_scp    = scope->num_scopes;
+    Scope* scps    = scope->scopes;
 
     /* Enable the behaviors. */
     for(i=0; i<num_beh; ++i) {
         behs[i]->enabled = status;
     }
+    /* Enable the codes. */
+    for(i=0; i<num_cod; ++i) {
+        cods[i]->enabled = status;
+    }
 
     /* Recurse on the sub scopes. */
     for(i=0; i<num_scp; ++i) {

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -505,7 +505,7 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
             }
 
         default:
-            perror("Invalid kind for an expression."); 
+            perror("Invalid kind for a statement."); 
     }
 }
 

data/lib/HDLRuby/hdr_samples/c_program/echo.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include "cHDL.h"
+
+#if defined(_WIN32) || defined(_WIN64)
+__declspec(dllexport)
+#endif
+void echo(void* code) {
+    static void* inP = NULL;
+    static void* outP = NULL;
+    unsigned long long data;
+
+    /* Is the input port obtained? */
+    if (inP == NULL) {
+        /* No, get it. */
+        inP = c_get_port("inP");
+    }
+
+    /* Is the input port obtained? */
+    if (outP == NULL) {
+        /* No, get it. */
+        outP = c_get_port("outP");
+    }
+
+    /* Get data from the input port. */
+    data = c_read_port(inP);
+
+    /* Display it. */
+    printf("Echoing: %llu\n", data);
+
+    /* Echoing the data. */
+    c_write_port(outP,data);
+
+}

data/lib/HDLRuby/hdr_samples/ruby_program/echo.rb

@@ -0,0 +1,9 @@
+require 'rubyHDL'
+
+# Ruby program ment to eb executed within HDLRuby hardware.
+
+def echo
+    val = RubyHDL.inP
+    puts "Echoing: #{val}"
+    RubyHDL.outP = val    
+end

data/lib/HDLRuby/hdr_samples/ruby_program/stdrw.rb

@@ -0,0 +1,6 @@
+require 'RubyHDL'
+
+def stdrw
+  RubyHDL.sigI = $stdin.read.to_i
+  $stdout.puts(RubyHDL.sigO)
+end