HDLRuby 3.9.1 → 3.9.5

data/README.md

@@ -71,7 +71,18 @@ hdrcc --get-tuto
 
 __What's New__
 
-For HDLRuby version 3.9.0:
+For HDLRuby version 3.9.3/3.9.4/3.9.5:
+
+* Improved the graphical representation of the RTL code in SVG format for faster generation and better rendering. The tool is still experimental though.
+
+* Fixed various bugs.
+
+
+For HDLRuby version 3.9.2:
+
+* Added the `hbreak` command for exiting parallel enumerator loops.
+
+For HDLRuby version 3.9.0/3.9.1:
 
 * Added the parallel enumerators to the software sequencers.
 
@@ -3981,6 +3992,10 @@ Parallel enumerators provide several control methods:
 
 * `+`: Concatenates two enumerators.
 
+Additionaly, it is possible to exit an enumeration loop using the following command:
+
+* `hbreak`: Exits the current enumeration loop.
+
 __Hardware Implementations of Enumerable Methods__
 
 Using parallel enumerators, HDLRuby provides hardware implementations of many Ruby Enumerable methods. These are available for any enumerable object and can be used inside or outside processes.

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -688,6 +688,7 @@ VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
     /* Get the type. */
     Type type;
     value_to_rcsim(TypeS,typeV,type);
+    // printf("type=%llu\n",type_width(type));
     /* Create the value. */
     Value value = make_value(type,0);
     // printf("value=%p\n",value);
@@ -703,6 +704,28 @@ VALUE rcsim_make_value_numeric(VALUE mod, VALUE typeV, VALUE contentV) {
     return res;
 }
 
+/* Creating a numeric value C object forcing bit 63 to one. */
+VALUE rcsim_make_value_numeric_63one(VALUE mod, VALUE typeV, VALUE contentV) {
+    // printf("rcsim_make_value_numeric_63one\n");
+    /* Get the type. */
+    Type type;
+    value_to_rcsim(TypeS,typeV,type);
+    // printf("type=%llu\n",type_width(type));
+    /* Create the value. */
+    Value value = make_value(type,0);
+    // printf("value=%p\n",value);
+    /* Set it to numeric. */
+    value->numeric = 1;
+    value->capacity = 0;
+    value->data_str = NULL;
+    value->data_int = NUM2LL(contentV) | 0x8000000000000000ULL;
+    // printf("value->data_int=%lld\n",value->data_int);
+    /* Returns the C value embedded into a ruby VALUE. */
+    VALUE res;
+    rcsim_to_value(ValueS,value,res);
+    return res;
+}
+
 
 /* Creating a bitstring value C object. */
 VALUE rcsim_make_value_bitstring(VALUE mod, VALUE typeV, VALUE contentV) {
@@ -760,6 +783,8 @@ VALUE rcsim_make_unary(VALUE mod, VALUE type, VALUE operator, VALUE child) {
     switch(sym_to_char(operator)) {
         case (unsigned char)'~':         unary->oper = not_value; break;
         case (unsigned char)('-'+'@'*2): unary->oper = neg_value; break;
+        case (unsigned char)'|':   unary->oper = reduce_or_value; break;
+        case (unsigned char)'&':  unary->oper = reduce_and_value; break;
         default: perror("Invalid operator for unary.");
     }
     value_to_rcsim(ExpressionS,child,unary->child);
@@ -1904,6 +1929,7 @@ void Init_hruby_sim() {
     rb_define_singleton_method(mod,"rcsim_make_hcase",rcsim_make_hcase,2);
     rb_define_singleton_method(mod,"rcsim_make_block",rcsim_make_block,1);
     rb_define_singleton_method(mod,"rcsim_make_value_numeric",rcsim_make_value_numeric,2);
+    rb_define_singleton_method(mod,"rcsim_make_value_numeric_63one",rcsim_make_value_numeric_63one,2);
     rb_define_singleton_method(mod,"rcsim_make_value_bitstring",rcsim_make_value_bitstring,2);
     rb_define_singleton_method(mod,"rcsim_make_cast",rcsim_make_cast,2);
     rb_define_singleton_method(mod,"rcsim_make_unary",rcsim_make_unary,3);

data/ext/hruby_sim/hruby_sim.h

@@ -252,6 +252,12 @@ extern Value not_value(Value src, Value dst);
  *  @return dst */
 extern Value reduce_or_value(Value src, Value dst);
 
+/** Compute the and of the bits a a value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+extern Value reduce_and_value(Value src, Value dst);
+
 /** Computes the AND of two values.
  *  @param src0 the first source value of the and
  *  @param src1 the second source value of the and

data/ext/hruby_sim/hruby_sim_calc.c

@@ -327,6 +327,7 @@ Value copy_value(Value src, Value dst) {
     /* Copy the data. */
     if (src->numeric) {
         /* Numeric copy. */
+        // printf("copy_value with data_in: %llu\n", src->data_int);
         dst->data_int = fix_numeric_type(dst->type,src->data_int);
     } else {
         // printf("copy_value with bit string: %.*s\n",src->capacity,src->data_str);
@@ -1348,6 +1349,44 @@ Value reduce_or_value_bitstring(Value src, Value dst) {
     return dst;
 }
 
+/** Compute the and of the bits a bitstring value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_and_value_bitstring(Value src, Value dst) {
+    /* Compute the width of the result in bits. */
+    unsigned long long width = type_width(src->type);
+
+    /* Update the destination capacity if required. */
+    resize_value(dst,width);
+    /* Set the type and size of the destination from the type of the source.*/
+    dst->type = src->type;
+    dst->numeric = 0;
+
+    /* Get access to the source and destination data. */
+    char* src_data = src->data_str;
+    char* dst_data = dst->data_str;
+
+    /* Performs the reduce or. */
+    unsigned long long count;
+    char res = 0;
+    for(count = 0; count < width; ++count) {
+        /* Performs the reduce and. */
+        char d = src_data[count] - '0'; /* Get and convert to bit. */
+        if ((d == (d&1)) && (res != 'x'-'0')) { /* d is defined. */
+            res &= d;
+        } else {
+            /* res is undefined. */
+            res = 'x' - '0';
+        }
+        /* Apart for the first bit, there are only 0, still we are in
+         * the loop, set it. */
+        dst_data[count] = '0';
+    }
+    dst_data[0] = res + '0';
+    /* Return the destination. */
+    return dst;
+}
 
 /** Computes the and of two bitstring values.
  *  @param src0 the first source value of the and
@@ -2128,7 +2167,6 @@ fix_numeric_type(Type type, unsigned long long val) {
     if (type->flags.sign) {
         /* Yes, perform sign extension. */
         int is_neg = (val >> (width-1)) & 1;
-        // printf("is_neg=%i\n",is_neg);
         if (is_neg) {
             /* Negative sign extension. */
             return val | mask;
@@ -2280,6 +2318,21 @@ Value reduce_or_value_numeric(Value src, Value dst) {
     return dst;
 }
 
+/** Compute the and of the bits a numeric value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_and_value_numeric(Value src, Value dst) {
+    /* Sets state of the destination using the first source. */
+    dst->type = src->type;
+    dst->numeric = 1;
+
+    /* Perform the reduce and. */
+    unsigned long long mask = ~(-1LL << type_width(src->type));
+    dst->data_int = fix_numeric_type(dst->type, (~src->data_int & mask) == 0);
+    return dst;
+}
+
 
 /** Computes the AND of two numeric values.
  *  @param src0 the first source value of the addition
@@ -3061,6 +3114,20 @@ Value reduce_or_value(Value src, Value dst) {
     }
 }
 
+/** Compute the and of the bits a value.
+ *  @param src the source value
+ *  @param dst the destination value
+ *  @return dst */
+Value reduce_and_value(Value src, Value dst) {
+    if (src->numeric) {
+        /* The source is numeric. */
+        return reduce_and_value_numeric(src,dst);
+    } else {
+        /* The source cannot be numeric, compute bitsitrings. */
+        return reduce_and_value_bitstring(src,dst);
+    }
+}
+
 
 /** Computes the AND of two general values. 
  *  @param src0 the first source value of the addition

data/lib/HDLRuby/hdr_samples/constant_prop_bench.rb

@@ -16,8 +16,8 @@ system :dff_bench do
     [8].inner :count
     [8].constant inc: 5
 
-    # counter(:my_counter).(clk,rst,inc,count)
-    counter(:my_counter).(clk,rst,5,count)
+    counter(:my_counter).(clk,rst,inc,count)
+    # counter(:my_counter).(clk,rst,5,count)
 
     # par do
     #     my_counter.inc <= 5