HDLRuby 3.7.8 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 343e43059315343f17e5999397af265b9d7c241ce527c57855b4b7d24d4c698a
-  data.tar.gz: d21dd89efe29eb843ad69c20ae802bad2c11d9d2ad5f6a2d96a904cdd72b9b33
+  metadata.gz: b3ecb1e50d09ad4ec7aa0809f93da534ce0672c30240aa9405124a075d29a015
+  data.tar.gz: 3b939a8ad0eeef795473657775a83c265597fa13939dae1c91bff685ab6024b4
 SHA512:
-  metadata.gz: 0ebc27526e8c259b80a40171e7eb65fa529c477621366296926acbb266f20dd44a55cff96a875cf77cf7c3d739d2d7f252281fec9671a06400829ae01f84883b
-  data.tar.gz: 36e07d94b685e170b815ca07f1e2c8e50b580b02c49602e8737aced082e606b3c269e1173c9ed92dee89d53418f1dc3a04491d0d9510992e4f04088062fca15e
+  metadata.gz: 60bf1dcdf1243053841f7033398fce2de880bb412b19142b2356ceaf05261adfde4cac6afe5a861b1026b30139836210c5fa42e496ba2d563822bf05b0333839
+  data.tar.gz: e6c56348b4e2cfa38cd0778e4d5d091b983c39b82af33df3cb11883f7ac5a40af920856cc2d9e8a2d79ee6084a82106d03c198c52a51456729d702ec67a8c819

data/README.md

@@ -17,6 +17,21 @@ hdrcc --get-tuto
 
 __What's new_
 
+For HDLRuby version 3.8.0:
+
+* Added parallel enumerators (e.g., heach): can iterate like Ruby for describing parallel hardware.
+
+* Added metaprogramming through standard HDLRuby constructs (e.g., hif): no need to use Ruby code any longer.
+
+* Fixed compile bugs for windows.
+
+
+For HDLRuby version 3.7.9:
+
+* Added Python code generation from the software sequencers.
+
+* Added [parallel enumerators](#parallel-enumerators-stdhruby_enumrb). 
+
 For HDLRuby versions 3.7.7/3.7.8:
 
 * Various fixes regqrding the software sequencers.
@@ -3256,6 +3271,125 @@ fsm(clk.posedge,rst,:static)
 end
 ```
 
+
+## Parallel Enumerators:: `std/hruby_enum.rb`
+<a name="enumertor"></a>
+
+HDLRuby parallel enumerators are objects for generating hardware processing series of signals in parallel. They are created using the method `heach` on parallel enumerable objects.
+
+Parallel enumerable objects include, arrays of signals and ranges.
+A parallel enumerable object can also be generated from an integer values using one of the following method:
+
+
+ - `<integer>.htimes`: is equivalent to the range `0..<integer-1>`.
+
+ - `<integer>.supto(<last>)`: is equivalent to the range `<integer>..<last>`.
+
+ - `<integer>.sdownto(<last>)`: is equivalent to the range `<last>..<integer>`.
+
+The parallel enumerators can be controlled using the following methods:
+
+ - `hsize`: returns the number of elements the enumerator can access.
+
+ - `htype`: returns the type of the elements accessed by the enumerator.
+
+ - `heach`: returns the current enumerator. If a block is given, it performs the iteration instead of returning an enumerator.
+
+ - `heach_with_index`: returns an enumerator over the elements of the current enumerator associated with their index position. If a block is given, it performs the iteration instead of returning an enumerator.
+
+ - `heach_with_object(<obj>)`: returns an enumerator over the elements of the current enumerator associated with object `obj` (any object, HDLRuby or not, can be used). If a block is given, it performs the iteration instead of returning an enumerator.
+
+ - `with_index`: identical to `seach_with_index`.
+
+ - `with_object(<obj>)`: identical to `seach_with_object`.
+
+ - `clone`: create a new enumerator on the same elements.
+
+ - `+`: concatenation of enumerators.
+
+
+With this basis, several algorithms have been implemented using enumerators and are usable for all the enumerable objects inside and outside proceses. All these algorithms are HW implantation of the Ruby Enumerable methods. They are accessible using the corresponding ruby method prefixed by character `h`. For example, the HW implementation of the ruby `all?` method is generated by the `hall?` method. In details:
+
+ - `hall?`: HW implementation of the Ruby `all?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hany?`: HW implementation of the Ruby `any?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hchain`: HW implementation of the Ruby `chain`.
+
+ - `hmap`: HW implementation of the Ruby `map` method. When used with a block returns a vector signal containing each computation result.
+
+ <!-- - `hcompact`: HW implementation of the Ruby `compact` method. However, since there is no nil value in HW, use 0 instead for compacting. Returns a vector signal containing the compaction result. -->
+
+ - `hcount`: HW implementation of the Ruby `count` method. Returns a signal whose bit width matches the size of the enumerator containing the count result.
+
+<!-- - `hcycle`: HW implementation of the Ruby `cycle` method. -->
+
+ - `hfind`: HW implementation of the Ruby `find` method. Returns a signal containing the found element, or 0 if not found.
+
+ - `hdrop`: HW implementation of the Ruby `drop` method. Returns a vector signal containing the remaining elements.
+
+<!-- - `hdrop_while`: HW implementation of the Ruby `drop_while` method. Returns a vector signal containing the remaining elements. -->
+
+ - `heach_cons`: HW implementation of the Ruby `each_cons` method.
+
+ - `heach_slice`: HW implementation of the Ruby `each_slice` method.
+
+ - `heach_with_index`: HW implementation of the Ruby `each_with_index` method.
+
+ - `heach_with_object`: HW implementation of the Ruby `each_with_object` method.
+
+ - `hto_a`: HW implementation of the Ruby `to_a` method. Returns a vector signal containing all the elements of the enumerator.
+
+<!-- - `hselect`: HW implementation of the Ruby `select` method. Returns a vector signal containing the selected elements. -->
+
+ - `hfind_index`: HW implementation of the Ruby `find_index` method. Returns the index of the found element or -1 if not.
+
+ - `hfirst`: HW implementation of the Ruby `first` method. Returns a vector signal containing the first elements.
+
+ - `hinclude?`: HW implementation of the Ruby `include?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hinject`: HW implementation of the Ruby `inject` method. Return a signal of the type of elements containing the computation result.
+
+ - `hmax`: HW implementation of the Ruby `max` method. Return a vector signal containing the found max values.
+ *Note:* For now only one max value can be returned.
+
+ - `hmax_by`: HW implementation of the Ruby `max_by` method. Return a vector signal containing the found max values.
+ *Note:* For now only one max value can be returned.
+
+ - `hmin`: HW implementation of the Ruby `min` method. Return a vector signal containing the found min values.
+ *Note:* For now only one min value can be returned.
+
+ - `hmin_by`: HW implementation of the Ruby `min_by` method. Return a vector signal containing the found min values.
+ *Note:* For now only one min value can be returned.
+
+ - `hminmax`: HW implementation of the Ruby `minmax` method. Returns a 2-element vector signal containing the resulting min and max values.
+
+ - `hminmax_by`: HW implementation of the Ruby `minmax_by` method. Returns a 2-element vector signal containing the resulting min and max values.
+
+ - `hnone?`: HW implementation of the Ruby `none?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+ - `hone?`: HW implementation of the Ruby `one?` method. Returns a single-bit signal. When 0 this value means false and when 1 it means true.
+
+<!--  - `hreject`: HW implementation of the Ruby `reject` method. Returns a vector signal containing the remaining elements. -->
+
+ - `hreverse_each`: HW implementation of the Ruby `reverse_each` method.
+ *Note:* This algorithm makes sense inside a `seq` process.
+
+ - `hsort`: HW implementation of the Ruby `sort` method. Returns a vector signal containing the sorted elements.
+ *Note:* If you use a custom comparison (passed as a Ruby block) and the number of elements to sort is not a power of 2, you need to provide as argument the maximum possible value (or minimum in case of decreasing order).
+
+ - `hsort_by`: HW implementation of the Ruby `sort_by` method. Returns a vector signal containing the sorted elements.
+ *Note:* If the number of elements to sort is not a power of 2, you need to provide as argument the maximum possible value (or minimum in case of decreasing order).
+
+ - `hsum`: HW implementation of the Ruby `sum` method. Returns a signal with the type of elements containing the sum result.
+
+ - `htake`: HW implementation of the Ruby `take` method. Returns a vector signal containing the taken elements.
+
+<!--  - `htake_while`: HW implementation of the Ruby `take_while` method. Returns a vector signal containing the taken elements. -->
+
+<!-- - `huniq`: HW implementation the Ruby `uniq` method. Returns a vector signal containing the selected elements. -->
+
+
 ## Sequencer (software-like hardware coding):: `std/sequencer.rb`
 <a name="sequencer"></a>
 
@@ -3394,9 +3528,9 @@ end
 ```
 
 
-### HDLRuby enumerators and enumerable objects: `std/sequencer.rb`
+### HDLRuby sequential enumerators and enumerable objects: `std/sequencer.rb`
 
-HDLRuby enumerators are objects for generating iterations within sequencers. They are created using the method `seach` on enumerable objects as presented in the previous section.
+HDLRuby sequential enumerators are objects for generating iterations within sequencers. They are created using the method `seach` on enumerable objects as presented in the previous section.
 
 The enumerators can be controlled using the following methods:
 
@@ -3850,6 +3984,18 @@ File.open("sequencer_in_ruby.rb","w") do |f|
 end
 ```
 
+It is also possible to generate C or Python code from the sequencer using the `to_c` and `to_python` methods, respectively. For example, the commands below generate a C file and a Python file from `my_seq`. However, the synchronization commands are not yet supported.
+
+```ruby
+File.open("seqiemcer_in_c.c","w" do |f|
+   f << my_seq.to_c
+end
+
+File.open("seqiemcer_in_python.py","w" do |f|
+   f << my_seq.to_python
+end
+```
+
 __Note__: the ruby code for sequencers is compatible with mruby for execution on embedded systems.
 
 
@@ -3990,7 +4136,7 @@ end.()
 
 Both method are functionally equivalent. However, the first is safer as potential errors are detected at the compile stage, but is incompatible with separated code generation and is slow, while the second allows separate code generation, if fast, but is less safe since it is only at the execution stage that the code is checked.
 
-__Note__: Since the string in text is grafted as is into the generated Ruby (or C) code, you cannot directly access the value of a signal. However, you can use to_ruby or to_c to access the underlying raw value, or use value_text to retrieve the value with proper type adjustment in case of overflow or underflow. For example, the following will display the raw value of signal sig0 and the hardware-accurate value of signal sig1:
+__Note__: Since the string in text is grafted as is into the generated Ruby (or C) code, you cannot directly access the value of a signal. However, you can use to_ruby, to_c or to_python to access the underlying raw value, or use value_text to retrieve the value with proper type adjustment in case of overflow or underflow. For example, the following will display the raw value of signal sig0 and the hardware-accurate value of signal sig1:
 
 ```ruby
 sequencer do

data/ext/hruby_sim/hruby_rcsim_build.c

@@ -280,7 +280,8 @@ VALUE rcsim_make_behavior(VALUE mod, VALUE timed) {
         register_init_behavior(behavior);
     }
     behavior->active_time = 0;
-    behavior->thread = NULL;
+    // behavior->thread = NULL;
+    behavior->thread = 0;
     /* Returns the C behavior embedded into a ruby VALUE. */
     VALUE res;
     rcsim_to_value(BehaviorS,behavior,res);
@@ -466,7 +467,8 @@ VALUE rcsim_load_c(VALUE mod, VALUE codeV, VALUE libnameV, VALUE funcnameV) {
         fprintf(stderr,"LoadLibrary failed with error code %ld\n", dwError);
         exit(-1);
     }
-    code->function = GetProcAddress(handle,funcname);
+    // code->function = GetProcAddress(handle,funcname);
+    code->function = (void (*)(Code))GetProcAddress(handle,funcname);
     if (code->function == NULL) {
         fprintf(stderr,"Unable to get function: %s\n",code->name);
         exit(-1);

data/ext/hruby_sim/hruby_sim_tree_calc.c

@@ -191,7 +191,7 @@ void calc_ref_rangeS(Reference ref, long long* first, long long *last,
         Cast refc = (Cast)ref;
         /* Compute the range for the child. */
         long long cfirst, clast;
-        calc_ref_rangeS(refc->child,&cfirst,&clast,sig);
+        calc_ref_rangeS((Reference)(refc->child),&cfirst,&clast,sig);
         /* Update first and last using the cast. */
         /* Both first and last should be equal since the type of the cast sets
          * the width */

data/ext/hruby_sim/hruby_sim_vcd.c

@@ -207,6 +207,76 @@ static void vcd_print_signal_cvalue(SignalI signal) {
 }
 
 
+/** Checks if a statement contains any declaration.
+ *  @param stmnt the statement to check. */
+static int vcd_statement_has_decl(Statement stmnt) {
+    // printf("stmnt kind=%d\n",stmnt->kind);
+    switch(stmnt->kind) {
+        case TRANSMIT: 
+        case PRINT:
+            /* No declaration. */
+            return 0;
+        case HIF:
+            {
+                HIf hif = (HIf)stmnt;
+                /* Recruse on the sub statements of the if.*/
+                if (vcd_statement_has_decl(hif->yes)) return 1;
+                for(int i=0; i<hif->num_noifs; ++i)
+                    if (vcd_statement_has_decl(hif->nostmnts[i])) 
+                        return 1;
+                if (hif->no)
+                    return vcd_statement_has_decl(hif->no);
+                /* No declaration. */
+                return 0;
+            }
+        case HCASE:
+            {
+                HCase hcase = (HCase)stmnt;
+                /* Recruse on the sub statements of the case.*/
+                for(int i=0; i<hcase->num_whens; ++i)
+                    if (vcd_statement_has_decl(hcase->stmnts[i]))
+                        return 1;
+                if (hcase->defolt)
+                    return vcd_statement_has_decl(hcase->defolt);
+                /* No declaration. */
+                return 0;
+            }
+        case TIME_WAIT:
+            /* No declaration. */
+            return 0;
+        case TIME_REPEAT:
+            {
+                TimeRepeat rep = (TimeRepeat)stmnt;
+                /* Recruse on the sub statements of the repeat.*/
+                for(long long i=0; i<rep->number; ++i)
+                    if (vcd_statement_has_decl(rep->statement))
+                        return 1;
+                /* No declaration. */
+                return 0;
+            }
+        case TIME_TERMINATE:
+            /* No declaration. */
+            return 0;
+        case BLOCK:
+            {
+                Block blk = (Block)stmnt;
+                if (blk->num_inners != 0) return 1;
+                /* Recruse on the sub statements. */
+                for(int i=0; i<blk->num_stmnts; ++i)
+                    if (vcd_statement_has_decl(blk->stmnts[i]))
+                        return 1;
+                /* No declaration. */
+                return 0;
+            }
+        default:
+            perror("Invalid kind for a statement."); 
+    }
+    /* Should not be here though. */
+    return 0;
+}
+
+
+
 /** Prints the hierarchy content of a system type.
  *  @param system the system to print. */
 static void vcd_print_systemT_content(SystemT system);
@@ -215,13 +285,74 @@ static void vcd_print_systemT_content(SystemT system);
  *  @param scope the scope to print. */
 static void vcd_print_scope(Scope scope);
 
+/** Prints the hierarchy of a block.
+ *  @param block the block to print. */
+static void vcd_print_block(Block block);
+
+/** Prints the hierarchy of a statement.
+ *  @param stmnt the statement to print. */
+static void vcd_print_statement(Statement stmnt) {
+    // printf("stmnt kind=%d\n",stmnt->kind);
+    switch(stmnt->kind) {
+        case TRANSMIT: 
+        case PRINT:
+            /* Nothing to do. */
+            break;
+        case HIF:
+            {
+                HIf hif = (HIf)stmnt;
+                /* Recruse on the sub statements of the if.*/
+                vcd_print_statement(hif->yes);
+                for(int i=0; i<hif->num_noifs; ++i)
+                    vcd_print_statement(hif->nostmnts[i]);
+                if (hif->no)
+                    vcd_print_statement(hif->no);
+                break;
+            }
+        case HCASE:
+            {
+                HCase hcase = (HCase)stmnt;
+                /* Recruse on the sub statements of the case.*/
+                for(int i=0; i<hcase->num_whens; ++i)
+                    vcd_print_statement(hcase->stmnts[i]);
+                if (hcase->defolt)
+                    vcd_print_statement(hcase->defolt);
+                break;
+            }
+        case TIME_WAIT:
+            /* Nothing to do. */
+            break;
+        case TIME_REPEAT:
+            {
+                TimeRepeat rep = (TimeRepeat)stmnt;
+                /* Recruse on the sub statements of the repeat.*/
+                for(long long i=0; i<rep->number; ++i)
+                    vcd_print_statement(rep->statement);
+                break;
+            }
+        case TIME_TERMINATE:
+            /* Nothing to do. */
+            break;
+        case BLOCK:
+            {
+                /* Block case: there is a specific function for it. */
+                vcd_print_block((Block)stmnt);
+                break;
+            }
+        default:
+            perror("Invalid kind for a statement."); 
+    }
+}
+
 
 /** Prints the hierarchy of a block.
  *  @param block the block to print. */
 static void vcd_print_block(Block block) {
     int i;
+    // printf("vcd_print_block\n");
     /* Do not print block with no declaration. */
-    if (block->num_inners == 0) return;
+    // if (block->num_inners == 0) return;
+    if (!vcd_statement_has_decl(block)) return;
 
     /* Declares the block if named. */
     vcd_print("$scope module ");
@@ -233,6 +364,11 @@ static void vcd_print_block(Block block) {
         vcd_print_var(block->inners[i]);
     }
 
+    /* Recurse on the statements if any. */
+    for(i=0; i<block->num_stmnts; ++i) {
+        vcd_print_statement(block->stmnts[i]);
+    }
+
     /* Close the hierarchy. */
     vcd_print("$upscope $end\n");
 }
@@ -258,6 +394,7 @@ static void vcd_print_systemI(SystemI systemI) {
  *  @param scope the scope to print the inside. */
 static void vcd_print_scope_content(Scope scope) {
     int i;
+    // printf("vcd_print_scope_content\n");
 
     /* Declare the inners of the systems. */
     for(i=0; i<scope->num_inners; ++i) {

data/lib/HDLRuby/hdr_samples/invalid_function.rb

@@ -0,0 +1,26 @@
+# Sample for testing an invalid function: should generate an error.
+
+
+hdef :func do |val|
+  [8].inner :res
+  hif (val == 1) { res <= _h60 }
+  helse          { res <= _h70 }
+end
+
+
+system :with_func do
+    [8].inner :val,:res
+
+    res <= func(val)
+
+    timed do
+        val <= 0
+        !10.ns
+        val <= 1
+        !10.ns
+        val <= 2
+        !10.ns
+        val <= 3
+        !10.ns
+    end
+end