HDLRuby 2.11.5 → 2.11.8

data/ext/hruby_sim/hruby_sim_core.c

@@ -35,6 +35,15 @@ static List touched_signals_seq = &touched_signals_seq_content;
 static ListS activate_codes_content = { NULL, NULL }; 
 static List activate_codes = &activate_codes_content;
 
+
+/** The number of behavior to run for initialization (not the timed ones!). */
+static int num_init_behaviors = 0;
+/** The capacity of teh behavior to run for initialization. */
+static int cap_init_behaviors = 0;
+/** The behaviors to run for initialization (not the timed ones!). */
+static Behavior* init_behaviors = 0;
+
+
 /** The number of timed behaviors. */
 static int num_timed_behaviors = 0;
 /** The capacity of the timed behaviors. */
@@ -88,12 +97,33 @@ void register_timed_behavior(Behavior behavior) {
 }
 
 
+/** Adds a behavior for initialization (not timed!).
+ *  @param beh the behavior to register. */
+void register_init_behavior(Behavior beh) {
+    if (num_init_behaviors == cap_init_behaviors) {
+        if (cap_init_behaviors == 0) {
+            /* Need to create the array containing the behaviors. */
+            cap_init_behaviors = 100;
+            init_behaviors = calloc(cap_init_behaviors,sizeof(Behavior));
+        } else {
+            /* Need to increase the capacity. */
+            Behavior* new_behs = calloc(cap_init_behaviors*2,sizeof(Behavior));
+            memcpy(new_behs,init_behaviors,sizeof(Behavior[cap_init_behaviors]));
+            cap_init_behaviors *= 2;
+            init_behaviors=new_behs;
+        }
+    }
+    /* Add the behavior. */
+    init_behaviors[num_init_behaviors++] = beh;
+}
+
+
 /** Adds a signal for global processing. 
  *  @param signal the signal to register  */
 void register_signal(SignalI signal) {
     if (num_all_signals == cap_all_signals) {
         if (cap_all_signals == 0) {
-            /* Need to create the array containing the timed behaviors. */
+            /* Need to create the array containing the signals. */
             cap_all_signals = 100;
             all_signals = calloc(cap_all_signals,sizeof(SignalI));
         } else {
@@ -110,6 +140,24 @@ void register_signal(SignalI signal) {
 }
 
 
+
+/** Initial run of the behaviors to init. */
+void run_init_behaviors() {
+    int i;
+    for(i = 0; i<num_init_behaviors; ++i) {
+        Behavior beh = init_behaviors[i];
+#ifdef RCSIM
+        // printf("Going to initialize behavior=%p with block=%p\n",beh,beh->block);fflush(stdout);
+        execute_statement((Statement)(beh->block),0,beh);
+#else
+        beh->block->function();
+#endif
+    }
+}
+
+
+
+
 /** Recursively update the signals until no (untimed) behavior are
  *  activated. */
 void hruby_sim_update_signals() {
@@ -304,6 +352,8 @@ void hruby_sim_advance_time() {
         if (timed_behaviors[i]->timed == 1)
             if (beh_time < next_time) next_time = beh_time;
     }
+    /* Mark again all the signals as fading. */
+    for(i=0; i<num_all_signals; ++i) all_signals[i]->fading = 1;
     // printf("hruby_sim_time=%llu next_time=%llu\n",hruby_sim_time,next_time);
     /* Sets the new activation time. */
     hruby_sim_time = next_time;
@@ -425,7 +475,6 @@ void* behavior_run(void* arg) {
 
 /** Starts a signle timed behavior to run without the multi-threaded engine. */
 void hruby_sim_start_single_timed_behavior() {
-    int i;
     // printf("hruby_sim_start_single_timed_behaviors\n");fflush(stdout);
     /* Set in mono-thread mode. */
     sim_single_flag = 1;
@@ -492,11 +541,16 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
     if (num_timed_behaviors == 1) {
         /* Initialize and touch all the signals. */
         hruby_sim_update_signals(); 
-        each_all_signal(&touch_signal);
+        // each_all_signal(&touch_signal);
+        run_init_behaviors();
         /* Only one timed behavior, no need of the multi-threaded engine. */
         hruby_sim_start_single_timed_behavior();
     } else {
         /* Use the multi-threaded engine. */
+        /* Initialize and touch all the signals. */
+        hruby_sim_update_signals(); 
+        // each_all_signal(&touch_signal);
+        run_init_behaviors();
         /* Start all the timed behaviors. */
         hruby_sim_start_timed_behaviors();
         // /* Activate the timed behavior that are on time. */
@@ -597,6 +651,7 @@ void touch_signal(SignalI signal) {
  *  @param value the value to transmit
  *  @param signal the signal to transmit the value to. */
 void transmit_to_signal(Value value, SignalI signal) {
+    // printf("Tansmit to signal: %s(%p)\n",signal->name,signal);
     /* Copy the content. */
     if (signal->fading)
         signal->f_value = copy_value(value,signal->f_value);
@@ -718,7 +773,6 @@ unsigned long long make_delay(int value, Unit unit) {
 
 
 
-
 /** Iterates over all the signals.
  *  @param func function to applie on each signal. */
 void each_all_signal(void (*func)(SignalI)) {

data/ext/hruby_sim/hruby_sim_mute.c

@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h>
+#include "hruby_sim.h"
+
+
+/**
+ *  The HDLRuby simulation mute output engine, to be used with C code
+ *  generated by the csim engine or by the rcsim engine. 
+ **/
+
+/* Global variables storing the configuration of the vcd generation. */
+
+
+
+/* Low-end print functions. */
+
+/** Prints the time.
+ *  @param time the time to show (given in ps). */
+static void mute_print_time(unsigned long long time) {
+}
+
+/** Prints the name of an object without its hierarchy.
+ *  @param object the object to print the name. */
+static void mute_print_name(Object object) {
+}
+
+/** Prints the full name of an object without its hierarchy.
+ *  @param object the object to print the name. */
+static void mute_print_full_name(Object object) {
+}
+
+/** Prints a value.
+ *  @param value the value to print */
+static void mute_print_value(Value value) {
+}
+
+/** Prints a signal with its future value if any.
+ *  @param signal the signal to show */
+static void mute_print_signal_fvalue(SignalI signal) {
+}
+
+/** Prints a signal with its current value if any
+ *  @param signal the signal to show */
+static void mute_print_signal_cvalue(SignalI signal) {
+}
+
+
+
+/* The configuration and initialization of the vcd vizualizer. */
+
+
+/** Sets up the mute vizualization engine.
+ *  @param name the name of the vizualization. */
+extern void init_mute_visualizer(char* name) {
+    /* Initialize the vizualizer printer engine. */
+    init_visualizer(&mute_print_time,
+                    &mute_print_full_name,
+                    &mute_print_value,
+                    &mute_print_signal_fvalue,
+                    &default_print_string,
+                    &default_print_name,
+                    &default_print_value);
+}

data/ext/hruby_sim/hruby_sim_stack_calc.c

@@ -106,6 +106,16 @@ Value binary(Value (*oper)(Value,Value,Value)) {
     return oper(l,r,peek());
 }
 
+/** Selection calculation.
+ * @param num the number of choices to select within. */
+Value hselect(unsigned int num) {
+    Value* vals = alloca(num*sizeof(Value));
+    int i;
+    /* Get the values to concat from the stack. */
+    for(i=1;i<=num;++i) vals[num-i] = pop();
+    return select_valueP(pop(),peek(),num,vals);
+}
+
 /** Cast calculation.
  *  @param typ the type to cast to.
  *  @return the destination.

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -46,11 +46,38 @@ Value calc_expression(Expression expr, Value res) {
                 Value right = get_value();
                 left = calc_expression(bexpr->left,left);
                 right = calc_expression(bexpr->right,right);
+                // printf("left=%.*s\n",left->capacity,left->data_str);
+                // printf("right=%.*s\n",right->capacity,right->data_str);
                 res = bexpr->oper(left,right,res);
                 free_value();
                 free_value();
                 break;
             }
+        case SELECT:
+            {
+                Select sexpr = (Select)expr;
+                /* Calculate the selection expression. */
+                Value selV = get_value();
+                selV = calc_expression(sexpr->select,selV);
+                /* Is the selection defined? */
+                if (is_defined_value(selV)) {
+                    /* Yes, can perform the selection. */
+                    long long sel = value2integer(selV);
+                    if (sel >= 0 && sel < sexpr->num_choices) {
+                        /* Possible choice, proceed the computation. */
+                        res = calc_expression(sexpr->choices[sel],res);
+                    }
+                } else {
+                    /* Cannot compute, simply undefines the destination. */
+                    /* First ensure res has the right shape. */
+                    res->type = sexpr->choices[0]->type;
+                    resize_value(res,type_width(res->type));
+                    /* Then make it undefined. */
+                    set_undefined_bitstring(res);
+                }
+                free_value();
+                break;
+            }
         case CONCAT:
             {
                 Concat cexpr = (Concat)expr;
@@ -70,7 +97,9 @@ Value calc_expression(Expression expr, Value res) {
                 Cast cexpr = (Cast)expr;
                 Value child = get_value();
                 child = calc_expression(cexpr->child,child);
+                // printf("going to cast value of numeric=%d and width=%llu to width=%llu\n",child->numeric,type_width(child->type),type_width(cexpr->type));
                 res = cast_value(child,cexpr->type,res);
+                // printf("result is numeric=%d\n",res->numeric);
                 free_value();
                 break;
             }
@@ -157,16 +186,15 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
         case TRANSMIT: 
             {
                 Transmit trans = (Transmit)stmnt;
-                // printf("trans=%p trans->left=%p trans->left->kind=%d\n",trans,trans->left,trans->left->kind);
                 /* Compute the right value. */
-                // Value right = calc_expression(trans->right);
                 Value right = get_value();
                 right = calc_expression(trans->right,right);
+                // printf("transmit to left=%p with kind=%d and right=%p with kind=%d\n",trans->left,trans->left->kind,trans->right,trans->right->kind);fflush(stdout);
                 /* Depending on the left value. */
                 switch (trans->left->kind) {
                     case SIGNALI:
                         // printf("left->name=%s\n",((SignalI)(trans->left))->name);
-                        fflush(stdout);
+                        // fflush(stdout);
                         /* Simple transmission. */
                         if (mode)
                             transmit_to_signal_seq(right,(SignalI)(trans->left));
@@ -178,7 +206,6 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                             /* Transmission to sub element. */
                             RefIndex refi = (RefIndex)(trans->left);
                             /* Compute the index. */
-                            // Value indexV = calc_expression(refi->index);
                             Value indexV = get_value();
                             indexV = calc_expression(refi->index,indexV);
                             long long index = value2integer(indexV);
@@ -231,8 +258,9 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                             /* For each sub reference. */
                             for(int i=0; i < refc->num_refs; ++i) {
                                 /* Set up the transmit. */
-                                subtrans.left = refc->refs[i];
-                                long long size = type_width(subtrans.left->type);
+                                subtrans.left = refc->refs[refc->num_refs-i-1];
+                                unsigned long long size = type_width(subtrans.left->type);
+                                // printf("i=%i left=%p left->type=%p &left->type=%p right->kind=%i pos=%llu size=%llu\n",i,subtrans.left,subtrans.left->type,&(subtrans.left->type),right->kind,pos,size,size);fflush(stdout);
                                 subtrans.right = (Expression)get_value();
                                 subtrans.right = (Expression)read_range(
                                         right,pos,pos+size-1,
@@ -244,6 +272,7 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                                 free_value();
                                 pos += size;
                             }
+                            break;
                         }
                     default:
                         perror("Invalid kind for a reference.");
@@ -279,7 +308,6 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
             {
                 HIf hif = (HIf)stmnt;
                 /* Calculation the condition. */
-                // Value condition = calc_expression(hif->condition);
                 Value condition = get_value();
                 condition = calc_expression(hif->condition,condition);
                 /* Is it true? */
@@ -290,7 +318,6 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                     /* No, maybe an alternate condition is met. */
                     int met = 0;/* Tell if an alternate condition has been met.*/
                     for(int i=0; i<hif->num_noifs; ++i) {
-                        // Value subcond = calc_expression(hif->noconds[i]);
                         Value subcond = get_value();
                         subcond = calc_expression(hif->noconds[i],subcond);
                         if (is_defined_value(subcond) && value2integer(subcond)){
@@ -305,7 +332,7 @@ void execute_statement(Statement stmnt, int mode, Behavior behavior) {
                         free_value();
                     }
                     /* Where there a sub condition met? */
-                    if (!met) {
+                    if (!met && hif->no) {
                         /* No, execute the no statement. */
                         execute_statement(hif->no,mode,behavior);
                     }

data/ext/hruby_sim/hruby_sim_vcd.c

@@ -7,7 +7,7 @@
 
 /**
  *  The HDLRuby simulation vcd format genertion engine, to be used with C code
- *  generated by hruby_low2c. 
+ *  generated by the csim engine or by the rcsim engine.
  **/
 
 /* Global variables storing the configuration of the vcd generation. */
@@ -74,20 +74,24 @@ static void vcd_print_name(Object object) {
         case SCOPE:
         case SYSTEMI:
         case BLOCK:
-            /* Print the name if name. */
-            /* Trick: SystemT, SignalI, Scope and SystemI have the
-             * field name at the same place. */
-            if ((((Block)object)->name != NULL) &&
-                    strlen(((Block)object)->name)>0) {
-                char name[256];
-                strncpy(name,((Block)object)->name,256);
-                replace_char(name,':','$');
-                vcd_print("%s",name);
-            } else {
-                /* No name, use the address of the object as name generator.*/
-                vcd_print("x$%p",(void*)object);
+            {
+                /* Print the name if name. */
+                /* Trick: SystemT, Block, Scope and SystemI have the
+                 * field name at the same place. */
+                char* namep = object->kind == SIGNALI ? 
+                    ((SignalI)object)->name : ((Block)object)->name;
+                if (namep!=NULL &&
+                        strlen(namep)>0) {
+                    char name[256];
+                    strncpy(name,namep,256);
+                    replace_char(name,':','$');
+                    vcd_print("%s",name);
+                } else {
+                    /* No name, use the address of the object as name generator.*/
+                    vcd_print("x$%p",(void*)object);
+                }
+                break;
             }
-            break;
         default: /* Nothing to do */
             break;
     }

data/lib/HDLRuby/hdr_samples/arith_bench.rb

@@ -0,0 +1,92 @@
+
+# A benchmark for the arithmetic operations.
+system :arith_bench do
+    signed[8].inner :x8,:y8,:z8,:s8
+    signed[10].inner :s10
+    signed[16].inner :x16,:y16,:z16,:s16
+    signed[18].inner :s18
+    signed[32].inner :x32,:y32,:z32,:s32
+    signed[34].inner :s34
+
+    s8 <= x8+y8+z8
+    s10 <= x8.as(signed[10])+y8+z8
+
+    s16 <= x16+y16+z16
+    s18 <= x16.as(signed[18])+y16+z16
+
+    s32 <= x32+y32+z32
+    s34 <= x32.as(signed[34])+y32+z32
+
+    timed do
+        x8  <= 0
+        y8  <= 0
+        z8  <= 0
+        x16 <= 0
+        y16 <= 0
+        z16 <= 0
+        x32 <= 0
+        y32 <= 0
+        z32 <= 0
+        !10.ns
+        x8  <= 1
+        y8  <= 1
+        z8  <= 1
+        x16 <= 1
+        y16 <= 1
+        z16 <= 1
+        x32 <= 1
+        y32 <= 1
+        z32 <= 1
+        !10.ns
+        x8  <= 2
+        y8  <= 2
+        z8  <= 2
+        x16 <= 4
+        y16 <= 4
+        z16 <= 4
+        x32 <= 8
+        y32 <= 8
+        z32 <= 8
+        !10.ns
+        x8  <= 0x7F
+        y8  <= 0x7F
+        z8  <= 0x7F
+        x16 <= 0x7FFF
+        y16 <= 0x7FFF
+        z16 <= 0x7FFF
+        x32 <= 0x7FFFFFFF
+        y32 <= 0x7FFFFFFF
+        z32 <= 0x7FFFFFFF
+        !10.ns
+        x8  <= -1
+        y8  <= -1
+        z8  <= -1
+        x16 <= -1
+        y16 <= -1
+        z16 <= -1
+        x32 <= -1
+        y32 <= -1
+        z32 <= -1
+        !10.ns
+        x8  <= -2
+        y8  <= -2
+        z8  <= -2
+        x16 <= -4
+        y16 <= -4
+        z16 <= -4
+        x32 <= -8
+        y32 <= -8
+        z32 <= -8
+        !10.ns
+        x8  <= -0x80
+        y8  <= -0x80
+        z8  <= -0x80
+        x16 <= -0x8000
+        y16 <= -0x8000
+        z16 <= -0x8000
+        x32 <= -0x80000000
+        y32 <= -0x80000000
+        z32 <= -0x80000000
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/constant_prop_bench.rb

@@ -0,0 +1,58 @@
+# A simple counter
+system :counter do
+    input :clk, :rst
+    [8].input  :inc
+    [8].output :count
+
+    par(clk.posedge) do
+        hif(rst) { count <= 0 }
+        helse    { count <= count + inc }
+    end
+end
+
+# A benchmark for the counter using a constant as the inc input.
+system :dff_bench do
+    inner :clk, :rst
+    [8].inner :count
+    [8].constant inc: 5
+
+    # counter(:my_counter).(clk,rst,inc,count)
+    counter(:my_counter).(clk,rst,5,count)
+
+    # par do
+    #     my_counter.inc <= 5
+    #     count <= my_counter.count
+    # end
+
+    timed do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        rst <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -380,6 +380,9 @@ $optparse = OptionParser.new do |opts|
         $options[:rcsim] = v
         $options[:multiple] = v
     end
+    opts.on("--mute", "The simulator will not generate any output") do |v|
+        $options[:mute] = v
+    end
     opts.on("--vcd", "The simulator will generate a vcd file") do |v|
         $options[:vcd] = v
     end
@@ -712,8 +715,9 @@ elsif $options[:clang] then
         $main = File.open($name,"w")
 
         # Select the vizualizer depending on the options.
-        init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
-                                           "init_default_visualizer"
+        init_visualizer = $options[:mute] ? "init_mute_visualizer" :
+                          $options[:vcd]  ? "init_vcd_visualizer" :
+                                            "init_default_visualizer"
 
         # Gather the system to generate and sort them in the right order
         # to ensure references are generated before being used.
@@ -857,9 +861,13 @@ elsif $options[:rsim] then
     HDLRuby.show "#{Time.now}#{show_mem}"
     # Ruby-level simulation.
     require 'HDLRuby/hruby_rsim.rb'
-    # Is VCD output is required.
-    if $options[:vcd] then
-        # Yes
+    # Is mute or VCD output is required.
+    if $options[:mute] then
+        # Yes for mute.
+        require "HDLRuby/hruby_rsim_mute.rb"
+        $top_system.sim($stdout)
+    elsif $options[:vcd] then
+        # Yes for VCD
         require "HDLRuby/hruby_rsim_vcd.rb"
         vcdout = File.open($output+"/hruby_simulator.vcd","w")
         $top_system.sim(vcdout)
@@ -881,7 +889,8 @@ elsif $options[:rcsim] then
     $top_system.to_rcsim
     HDLRuby.show "Executing the hybrid C-Ruby-level simulator..."
     HDLRuby.show "#{Time.now}#{show_mem}"
-    HDLRuby::High.rcsim($top_system,"hruby_simulator",$output,$options[:vcd] && true)
+    HDLRuby::High.rcsim($top_system,"hruby_simulator",$output,
+                        ($options[:mute] && 1) || ($options[:vcd] && 2) || 0)
     HDLRuby.show "End of hybrid C-Ruby-level simulation..."
     HDLRuby.show "#{Time.now}#{show_mem}"
 elsif $options[:vhdl] then

data/lib/HDLRuby/hruby_bstr.rb

@@ -51,7 +51,9 @@ module HDLRuby
             elsif val.is_a?(Numeric) then
                 # Content is a numeric.
                 @content = []
-                if val > 0 then
+                if val == 0 then
+                    @content << 0
+                elsif val > 0 then
                     while val > 0 do
                         @content << (val & 1)
                         val /= 2
@@ -110,6 +112,11 @@ module HDLRuby
             return @content
         end
 
+        # Hash comparison.
+        def eql?(bstr)
+            return @content.eql?(bstr.raw_content)
+        end
+
         # Tells if the bit string is strictly.
         #
         # NOTE: return false if the sign is undefined of if it is unknown
@@ -180,10 +187,14 @@ module HDLRuby
                 if right >= left then
                     # puts "left=#{left} right=#{right}"
                     # Get the corresponding bits as a BitString
-                    return BitString.new(@content[left..right],:raw)
+                    # return BitString.new(@content[left..right],:raw)
+                    # set to positive.
+                    return BitString.new(@content[left..right]+[0],:raw)
                 else
                     # Get the corresponding bits as a BitString
-                    return BitString.new(@content[right..left].reverse,:raw)
+                    # return BitString.new(@content[right..left].reverse,:raw)
+                    # set to positive.
+                    return BitString.new(@content[right..left].reverse+[0],:raw)
                 end
             else
                 # Process the index.
@@ -532,6 +543,7 @@ module HDLRuby
                     val = BitString.new(val)
                 end
                 vcontent = val.raw_content
+                # puts "vcontent=#{vcontent}"
                 width = vcontent.size > @content.size ? vcontent.size : @content.size
                 res_content = width.times.map do |i|
                     # Get the bits to compute with

data/lib/HDLRuby/hruby_high.rb

@@ -4213,7 +4213,7 @@ module HDLRuby::High
         # Creates a new +type+ sort of block with possible +name+
         # and build it by executing +ruby_block+.
         def initialize(type, name = :"", &ruby_block)
-            # Initialize the block.
+            # Initialize the behavior.
             super(type,name)
 
             unless name.empty? then
@@ -4674,7 +4674,11 @@ module HDLRuby::High
     class ::Integer
         # Converts to a new high-level expression.
         def to_expr
-            return Value.new(Integer,self)
+            if (self.bit_length <= 63) then
+                return Value.new(Integer,self)
+            else
+                return Value.new(TypeSigned.new(:"",self.bit_length..0),self)
+            end
         end
     end
     
@@ -5168,9 +5172,9 @@ module HDLRuby::High
 
 
     # Standard vector types.
-    Integer = TypeSigned.new(:integer)
+    Integer = TypeSigned.new(:integer,63..0)
     Char    = TypeSigned.new(:char,7..0)
-    Natural = TypeUnsigned.new(:natural)
+    Natural = TypeUnsigned.new(:natural,63..0)
     Bignum  = TypeSigned.new(:bignum,HDLRuby::Infinity..0)
     Real    = TypeFloat.new(:float)