HDLRuby 2.4.27 → 2.6.2

data/lib/HDLRuby/sim/hruby_sim.h

@@ -573,10 +573,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 +590,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_vcd.c

@@ -357,6 +357,7 @@ static void vcd_print_header() {
 }
 
 
+
 /* The configuration and initialization of the vcd vizualizer. */
 
 
@@ -373,7 +374,10 @@ extern void init_vcd_visualizer(char* name) {
     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

data/lib/HDLRuby/std/hruby_unit.rb

@@ -0,0 +1,75 @@
+require "HDLRuby/hruby_high"
+
+
+
+##
+# Library for building unit test systems.
+#
+########################################################################
+module HDLRuby::Unit
+
+    ## The HDLRuby unit test error class.
+    class UnitError < ::StandardError
+    end
+
+    # The set of the unit systems by name.
+    @@unit_systems = {}
+
+
+    # Declares system +name+ for unit testing.
+    # The system is built by executing +ruby_block+.
+    #
+    # NOTE: the name of the system is not registered within the HDLRuby
+    #       namespace since it is not meant to be used directly.
+    def self.system(name,&ruby_block)
+        # Ensure name is a symbol.
+        name = name.to_s.to_sym unless name.is_a?(Symbol)
+        # Check if the name is already used or not.
+        if @@unit_systems.key?(name) then
+            raise UnitError, "Unit test system #{name} already declared."
+        end
+        # @@unit_systems[name] = HDLRuby::High.system(&ruby_block)
+        @@unit_systems[name] = ruby_block
+    end
+
+
+    # Create a system named +test_name+ executing the unit tests given from
+    # +names+.
+    def self.test(test_name = :test, *names)
+        # If there is no name given, use all the test systems.
+        names = @@unit_systems.each_key if names.empty?
+        # Declare the system.
+        HDLRuby::High.system test_name do
+
+            # The timed block that contains the bench execurtion code.
+            @@tester = timed {}
+
+            # Generate the test code for each selected test units.
+            names.each do |name|
+                name = name.to_s.to_sym unless name.is_a?(Symbol)
+                unless @@unit_systems.key?(name) then
+                    raise UnitError, "Unit test #{name} does not exist."
+                end
+                sub(name) do
+                    @@myself = self
+                    instance_exec do
+                        # Define the test command that insert code of
+                        # the current test unit to the tester timed block.
+                        def test(&ruby_block)
+                            @@tester.block.open do
+                                # Here the signals are to be taken from
+                                # the test unit and not the timed block.
+                                set_this(@@myself)
+                                ruby_block.call
+                                # Go back to the default current this.
+                                set_this
+                            end
+                        end
+                    end
+                    # Process the test unit.
+                    instance_exec(&@@unit_systems[name])
+                end
+            end
+        end
+    end
+end