HDLRuby 2.5.0 → 2.6.5

data/lib/HDLRuby/sim/hruby_sim.h

@@ -451,7 +451,10 @@ typedef struct BehaviorS_ {
 
     int activated;      /* Tells if the behavior is activated or not. */
 
-    int timed;          /* Tell if the behavior is timed or not. */
+    int timed;          /* Tell if the behavior is timed or not:
+                           - 0: not timed
+                           - 1: timed
+                           - 2: timed and finished. */
     unsigned long long active_time; /* The next time the behavior has to be activated. */
     pthread_t thread;   /* The thread assotiated with the behavior (if any).*/
 } BehaviorS;
@@ -573,10 +576,15 @@ extern void each_all_signal(void (*func)(SignalI));
 /* Interface to the visualization engine. */
 
 typedef struct {
+    /* The simulation prints. */
     void (*print_time)(unsigned long long);
     void (*print_name)(Object);
     void (*print_value)(Value);
     void (*print_signal)(SignalI);
+    /* The custom 'string' prints. */
+    void (*print_string)(const char*);
+    void (*print_string_name)(Object);
+    void (*print_string_value)(Value);
 } PrinterS;
 
 extern PrinterS printer;
@@ -585,11 +593,29 @@ extern PrinterS printer;
  *  @param print_time the time printer
  *  @param print_name the name printer
  *  @param print_value the value printer
- *  @param print_signal the signal state printer. */
+ *  @param print_signal the signal state printer
+ *  @param print_string the string printer
+ *  @param print_string_name the string name printer
+ *  @param print_string_value the string value printer */
 extern void init_visualizer(void (*print_time)(unsigned long long), 
                             void (*print_name)(Object),
                             void (*print_value)(Value),
-                            void (*print_signal)(SignalI));
+                            void (*print_signal)(SignalI),
+                            void (*print_string)(const char*),
+                            void (*print_string_name)(Object),
+                            void (*print_string_value)(Value));
+
+/** Prints a name (default).
+ *  @param signal the signal to show */
+extern void default_print_name(Object);
+
+/** Prints a value (default).
+ *  @param signal the signal to show */
+extern void default_print_value(Value);
+
+/** Prints a string (default).
+ *  @param str the string to print. */
+extern void default_print_string(const char* str);
 
 // /** Prints the time.
 //  *  @param time the time to show. */

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -325,6 +325,9 @@ Value copy_value(Value src, Value dst) {
 /* Declared afterward. */
 static Value set_bitstring_value(Value src, Value dst);
 
+/* Declared afterward. */
+static Value set_numeric_value(Value src, Value dst);
+
 /** Copies a value to another but without overwritting with Z, the type of 
  *  the destination is preserved.
  *  @param src the source value
@@ -393,6 +396,35 @@ static Value set_bitstring_value(Value src, Value dst) {
     return dst;
 }
 
+/** Creates a numeric value from a bitstring value.
+ *  @param src the bitstring source value
+ *  @param dst the numeric destination value
+ *  @return dst. */
+static Value set_numeric_value(Value src, Value dst) {
+    /* Compute the width in bits of the source. */
+    unsigned long long width = type_width(src->type);
+    unsigned long long i;
+    /* Set the type and size of the destination from the type of the source.*/
+    dst->type = src->type;
+    dst->numeric = 1;
+
+    /* Access the data of the source and the destination. */
+    char* data_str = src->data_str;
+    unsigned long long data_int = 0;
+
+    /* Make the conversion. */
+    for(i=0; i < width; ++i) {
+        /* Get the bit from the source. */
+        unsigned long long bit = data_str[i] - '0';
+        /* And write it. */
+        data_int |= bit << i;
+    }
+    /* Update the destination. */
+    dst->data_int = data_int;
+    /* Return the destination. */
+    return dst;
+}
+
 
 /** Sets a value to undefined.
  *  @param dst the destination value
@@ -1620,7 +1652,7 @@ static Value not_value_numeric(Value src, Value dst) {
     dst->numeric = 1;
 
     /* Perform the not. */
-    dst->data_int = fix_numeric_type(dst->type,!src->data_int);
+    dst->data_int = fix_numeric_type(dst->type,~src->data_int);
     return dst;
 }
 
@@ -1731,7 +1763,8 @@ static Value equal_value_numeric(Value src0, Value src1, Value dst) {
     dst->numeric = 1;
 
     /* Perform the !XOR. */
-    dst->data_int = (src0->data_int == src1->data_int);
+    // dst->data_int = (src0->data_int == src1->data_int);
+    dst->data_int = ~(src0->data_int ^ src1->data_int);
     return dst;
 }
 
@@ -2068,15 +2101,39 @@ Value sub_value(Value src0, Value src1, Value dst) {
  *  @param dst the destination value
  *  @return dst */
 Value mul_value(Value src0, Value src1, Value dst) {
+    // printf("mul_value with src0=%llx src1=%llx\n",value2integer(src0),value2integer(src1));
+    // printf("src0->numeric=%d src1->numeric=%d\n",src0->numeric,src1->numeric);
+    // printf("is_defined_value(src0)=%d is_defined_value(src1)=%d\n",is_defined_value(src0),is_defined_value(src1));
     /* Might allocate a new value so save the current pool state. */
     unsigned int pos = get_value_pos();
     /* Do a numeric computation if possible, otherwise fallback to bitstring
      * computation. */
-    if (src0->numeric && src1->numeric) {
-        /* Both sources are numeric. */
-        return mul_value_numeric(src0,src1,dst);
+    if (src0->numeric) {
+        if (src1->numeric) {
+            /* Both sources are numeric. */
+            return mul_value_numeric(src0,src1,dst);
+        } else if (is_defined_value(src1)) {
+            // /* src1 is a defined bitstring, convert src0 to bitstring. */
+            // src0 = set_bitstring_value(src0,get_value());
+            // /* And do a bitstring multiplying. */
+            // return mul_value_defined_bitstring(src0,src1,dst);
+            /* src1 is a defined bitstring, convert it to a numeric. */
+            src1 = set_numeric_value(src1,get_value());
+            /* And do a numeri multiplying. */
+            return mul_value_numeric(src0,src1,dst);
+        }
+    } else if (src1->numeric && is_defined_value(src0)) {
+        // /* src1 is numeric but src0 is a defined bitstring, convert src1 to
+        //  * bitstring. */
+        // src1 = set_bit_string_value(src1,get_value());
+        // /* And do a bitstring multiplying. */
+        // return mul_value_defined_bitstring(src0,src1,dst);
+            /* src0 is a defined bitstring, convert it to a numeric. */
+            src0 = set_numeric_value(src0,get_value());
+            /* And do a numeri multiplying. */
+            return mul_value_numeric(src0,src1,dst);
     } else if (is_defined_value(src0) && is_defined_value(src1)) {
-        /* Both sources can be converted to numeric values. */
+        /* Both sources are defined bitstrings. */
         return mul_value_defined_bitstring(src0,src1,dst);
     } else {
         /* Cannot compute (for now), simply undefines the destination. */

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -285,7 +285,8 @@ void hruby_sim_advance_time() {
     int i;
     for(i=0; i<num_timed_behaviors; ++i) {
         unsigned long long beh_time = timed_behaviors[i]->active_time;
-        if (beh_time < next_time) next_time = beh_time;
+        if (timed_behaviors[i]->timed == 1)
+            if (beh_time < next_time) next_time = beh_time;
     }
     /* Sets the new activation time. */
     hruby_sim_time = next_time;
@@ -310,7 +311,9 @@ void hruby_sim_activate_behaviors_on_time() {
     /* Count the number of behaviors that will be activated. */
     for(i=0; i<num_timed_behaviors; ++i) {
         Behavior beh = timed_behaviors[i];
-        if (beh->active_time == hruby_sim_time) {
+        // printf("beh->active_time=%llu\n",beh->active_time);
+        // if (beh->active_time == hruby_sim_time) {
+        if (beh->timed == 1 && beh->active_time == hruby_sim_time) {
             /* Increase the number of timed behavior to wait for. */
             num_active_behaviors ++;
             // printf("num_active_behaviors = %d\n",num_active_behaviors);
@@ -318,18 +321,19 @@ void hruby_sim_activate_behaviors_on_time() {
     }
     /* Activate the behaviors .*/
     behaviors_can_run = 1;
+    // printf("$2\n");
     // pthread_cond_signal(&compute_cond); /* No behaviors. */
-    pthread_cond_signal(&hruby_beh_cond); 
+    // pthread_cond_signal(&hruby_beh_cond); 
     pthread_mutex_unlock(&hruby_sim_mutex);
-    // printf("$2\n");
+    pthread_cond_broadcast(&hruby_beh_cond); 
 }
 
 
 /** Wait for the active timed behaviors to advance. */
 void hruby_sim_wait_behaviors() {
-    // printf("$3\n");
     pthread_mutex_lock(&hruby_sim_mutex);
     while(num_active_behaviors > 0) {
+        // printf("$3\n");
         // printf("num_active_behaviors = %d\n",num_active_behaviors);
         // pthread_cond_wait(&active_behaviors_cond, &hruby_sim_mutex);
         pthread_cond_wait(&hruby_sim_cond, &hruby_sim_mutex);
@@ -349,6 +353,7 @@ void* behavior_run(void* arg) {
     pthread_mutex_lock(&hruby_sim_mutex);
     num_active_behaviors -= 1;
     while(!behaviors_can_run) {
+        // printf("cannot run\n");
         // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
         pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
     }
@@ -356,12 +361,17 @@ void* behavior_run(void* arg) {
     // printf("#2\n");
     /* Now can start the execution of the behavior. */
     behavior->block->function();
+    // printf("#3\n");
+    /* Now can start the execution of the behavior. */
     /* Stops the behavior. */
     pthread_mutex_lock(&hruby_sim_mutex);
     num_active_behaviors -= 1;
     num_run_behaviors -= 1;
-    pthread_cond_signal(&hruby_sim_cond);
+    // printf("num_run_behaviors=%d\n",num_run_behaviors);
+    behavior->timed = 2;
+    // pthread_cond_signal(&hruby_sim_cond);
     pthread_mutex_unlock(&hruby_sim_mutex);
+    pthread_cond_signal(&hruby_sim_cond);
     /* End the thread. */
     pthread_exit(NULL);
 }
@@ -374,11 +384,13 @@ void hruby_sim_start_timed_behaviors() {
     pthread_mutex_lock(&hruby_sim_mutex);
     /* Sets the end flags to 0. */
     sim_end_flag = 0;
+    /* Tells the behavior can run. */
+    behaviors_can_run = 1;
     /* Create and start the threads. */
     for(i=0; i<num_timed_behaviors; ++i) {
         num_run_behaviors += 1;
         // ++num_active_behaviors;
-        // printf("0 num_active_behaviors = %d\n",num_active_behaviors);
+        // printf("0 num_run_behaviors = %d\n",num_run_behaviors);
         pthread_create(&timed_behaviors[i]->thread,NULL,
                        &behavior_run,timed_behaviors[i]);
     }
@@ -457,7 +469,6 @@ void hruby_sim_core(char* name, void (*init_vizualizer)(char*),
  *  @param delay the delay to wait in fs.
  *  @param behavior the current behavior. */
 void hw_wait(unsigned long long delay, Behavior behavior) {
-    // printf("!1\n");
     /* Maybe the thread is to end immediatly. */
     if (sim_end_flag)
         pthread_exit(NULL);
@@ -465,16 +476,20 @@ void hw_wait(unsigned long long delay, Behavior behavior) {
     pthread_mutex_lock(&hruby_sim_mutex);
     /* Indicate the behavior finished current execution. */
     num_active_behaviors -= 1;
-    pthread_cond_signal(&hruby_sim_cond);
+    // printf("!!num_active_behaviors=%d\n",num_active_behaviors);
+    // pthread_cond_signal(&hruby_sim_cond);
     /* Update the behavior's time. */
     behavior->active_time += delay;
     pthread_mutex_unlock(&hruby_sim_mutex);
+    pthread_cond_signal(&hruby_sim_cond);
     /* Wait for being reactivated. */
     while(behavior->active_time > hruby_sim_time) {
         pthread_mutex_lock(&hruby_sim_mutex);
         while(!behaviors_can_run) {
+            // printf("!1\n");
             // pthread_cond_wait(&compute_cond, &hruby_sim_mutex);
             pthread_cond_wait(&hruby_beh_cond, &hruby_sim_mutex);
+            // printf("!2\n");
         }
         pthread_mutex_unlock(&hruby_sim_mutex);
     }

data/lib/HDLRuby/sim/hruby_sim_vcd.c

@@ -357,6 +357,7 @@ static void vcd_print_header() {
 }
 
 
+
 /* The configuration and initialization of the vcd vizualizer. */
 
 
@@ -365,15 +366,18 @@ static void vcd_print_header() {
 extern void init_vcd_visualizer(char* name) {
     /* Open the resulting file with name: <name>.vcd */
     char filename[256];
-    strncpy(filename,name,256);
-    strncat(filename,".vcd",256);
+    strncpy(filename,name,255);
+    strncat(filename,".vcd",255);
     vcd_file = fopen(filename,"w");
 
     /* Initialize the vizualizer printer engine. */
     init_visualizer(&vcd_print_time,
                     &vcd_print_full_name,
                     &vcd_print_value,
-                    &vcd_print_signal_fvalue);
+                    &vcd_print_signal_fvalue,
+                    &default_print_string,
+                    &default_print_name,
+                    &default_print_value);
 
     /* Prints the header of the vcd file. */
     vcd_print_header();

data/lib/HDLRuby/sim/hruby_sim_vizualize.c

@@ -16,15 +16,22 @@ PrinterS printer;
  *  @param print_time the time printer
  *  @param print_name the name printer
  *  @param print_value the value printer
- *  @param print_signal the signal state printer. */
+ *  @param print_signal the signal state printer
+ *  @param print_string the string printer. */
 void init_visualizer(void (*print_time)(unsigned long long), 
                      void (*print_name)(Object),
                      void (*print_value)(Value),
-                     void (*print_signal)(SignalI)) {
+                     void (*print_signal)(SignalI),
+                     void (*print_string)(const char*),
+                     void (*print_string_name)(Object),
+                     void (*print_string_value)(Value)) {
     printer.print_time = print_time; 
     printer.print_name = print_name; 
     printer.print_value = print_value; 
     printer.print_signal = print_signal; 
+    printer.print_string = print_string;
+    printer.print_string_name = print_string_name;
+    printer.print_string_value = print_string_value;
 }
 
                     
@@ -34,7 +41,7 @@ void init_visualizer(void (*print_time)(unsigned long long),
 
 /** Prints the time.
  *  @param time the time to show. */
-static void default_print_time(unsigned long long time) {
+void default_print_time(unsigned long long time) {
     printf("# %llups",time);
 }
 
@@ -47,7 +54,7 @@ static void default_println_time(unsigned long long time) {
 
 /** Prints the name of an object.
  *  @param object the object to print the name. */
-static void default_print_name(Object object) {
+void default_print_name(Object object) {
     /* Recurse on the owner if any. */
     // printf("owner=%p\n",object->owner);
     if (object->owner != NULL) {
@@ -73,7 +80,7 @@ static void default_print_name(Object object) {
 
 /** Prints a value.
  *  @param value the value to print */
-static void default_print_value(Value value) {
+void default_print_value(Value value) {
     if (value->numeric) {
         unsigned long long width = type_width(value->type);
         unsigned long long mask = 1ULL << (width-1);
@@ -100,6 +107,12 @@ static void default_print_value(Value value) {
     }
 }
 
+/** Prints a string.
+ *  @param str the string to print. */
+void default_print_string(const char* str) {
+    printf("%s", str);
+}
+
 /** Prints a signal.
  *  @param signal the signal to show */
 static void default_print_signal(SignalI signal) {
@@ -126,5 +139,8 @@ void init_default_visualizer(char* name) {
     init_visualizer(&default_println_time,
                     &default_print_name,
                     &default_print_value,
-                    &default_println_signal);
+                    &default_println_signal,
+                    &default_print_string,
+                    &default_print_name,
+                    &default_print_value);
 }

data/lib/HDLRuby/std/fixpoint.rb

@@ -65,6 +65,15 @@ module HDLRuby::High::Std
                                 (left.as([isize+fsize*2]) << fsize) / right
                             end
                         end
+                        # Define the removal of the point.
+                        typ.define_singleton_method(:no_point) do
+                            if (typ.signed?) then
+                                signed[typ.width]
+                            else
+                                bit[typ.width]
+                            end
+                        end
+                        # Return the resulting typ.
                         typ
                     end
                 end

data/lib/HDLRuby/std/function_generator.rb

@@ -0,0 +1,139 @@
+##
+# Standard HDLRuby::High library: universal generic function generator
+# based on the work of Ryota Sakai from NN4H
+# 
+########################################################################
+
+
+module HDLRuby::High::Std
+
+    # Module describing a function generator using linear approximation between
+    # fixed precalculated values.
+    # Generic parameters:
+    # +func+   procedure generating the discret values of the functions.
+    # +ityp+   the type of the input
+    # +otyp+   the type of the output
+    # +awidth+ width of the address bus for accessing the discret values
+    # +xrange+ the range for x values when computing the function
+    # +yrange+ the range for y values when computing the function
+    system :function_generator do |func, ityp, otyp, awidth, xrange, yrange|
+        # Check the generic parameters.
+        func = func.to_proc
+        ityp = ityp.to_type
+        otyp = otyp.to_type
+        awidth = awidth.to_i
+        xrange = xrange.first.to_f..xrange.last.to_f
+        yrange = yrange.first.to_f..yrange.last.to_f
+
+        # Declare the interface of the generator.
+        ityp.input :x
+        otyp.output :y
+
+        # Discrete values used for interpolating.
+        otyp.inner :base, :next_data
+
+        # Address
+        [awidth].inner :address
+        # Remainder
+        ityp.inner :remaining
+        x
+        # Compute the address and the remainder from the input.
+        address <= x[(ityp.width-1)..(ityp.width-awidth)]
+        remaining <= [[_b1b0] * awidth, x[(ityp.width-1-awidth)..0]]
+
+        # Instantiate the lut holding the discrete values.
+        lut(func,ityp,otyp,awidth,xrange,yrange).(:my_lut).(address,base,next_data)
+
+        # Instantiate the interpolator.
+        interpolator(ityp,otyp,awidth).(:my_iterpolator).(base,next_data, remaining, y)
+    end
+
+
+    # The LUT containing the discre values.
+    system :lut do |func,ityp, otyp, awidth, xrange, yrange|
+        # Check the generic arguments.
+        func = func.to_proc
+        ityp = ityp.to_type
+        otyp = otyp.to_type
+        awidth = awidth.to_i
+        xrange = xrange.first.to_f..xrange.last.to_f
+        yrange = yrange.first.to_f..yrange.last.to_f
+
+        # lut_size = 2 ** address_width
+        # Compute the size of the lut.
+        lut_size = 2 ** awidth
+
+        # Declare the input and output of the lut.
+        [awidth].input :address
+        otyp.output :base, :next_data
+
+        # Declare the lut
+        otyp[-lut_size].constant lut: 
+            initialize_lut(func,otyp,awidth,xrange,yrange)
+
+        # Assign the base discret value.
+        base <= lut[address]
+
+        # Assign the next_data discrete value.
+        next_data <= lut[address+1]
+    end
+
+
+    # compute tanh
+    # LUTの点の間の値を計算するモジュール
+    # system :interpolator do |typ, integer_width, address_width|
+    # Module making linear interpolation between two discrete values.
+    # Generic parameters:
+    # +ityp+: the function input value type
+    # +otyp+: the function output value type
+    # +width+: the step width between discrete values
+    system :interpolator do |ityp,otyp,width|
+        # Check the generic arguments
+        ityp = ityp.to_type
+        otyp = otyp.to_type
+        width = width.to_i
+        # Compute the scale factor and convert it to a shift value.
+        shift_bits = ityp.width - width
+
+        # Declare the input and outputs.
+        otyp.input :base, :next_data
+        ityp.input :remaining
+        otyp.output :interpolated_value
+
+        if (otyp.signed?) then
+            signed[otyp.width+ityp.width].inner :diff
+        else
+            bit[otyp.width+ityp.width].inner :diff
+        end
+
+        # Make the interpolation.
+        diff <= (next_data-base).as(diff.type) * remaining
+        if(otyp.signed?) then
+            interpolated_value <= base + 
+                ([[diff[diff.type.width-1]]*shift_bits,
+                  diff[diff.type.width-1..shift_bits]]).to_expr
+        else
+            interpolated_value <= base + (diff >> shift_bits)
+        end
+    end
+
+    # Make an array consists of a point of any activation function.
+    # @param [Integer] lut_size the lut_size of LUT
+    # @return [Array] table an array consists of a point of tanh
+    def initialize_lut(func, otyp, awidth, xrange, yrange)
+        # Compute the x step between discret values.
+        xstep = (xrange.last-xrange.first)/(2 ** awidth)
+
+        # Generate the discrete set of x values.
+        x_values = xrange.step(xstep)
+        # Generate the table.
+        table = x_values.map do |x_value|
+            ((func.call(x_value)-yrange.first)/(yrange.last-yrange.first)*
+             2**otyp.width).to_i.to_expr.as(otyp)
+        end
+
+        return table
+    end
+
+
+end