HDLRuby 3.7.8 → 3.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 343e43059315343f17e5999397af265b9d7c241ce527c57855b4b7d24d4c698a
-  data.tar.gz: d21dd89efe29eb843ad69c20ae802bad2c11d9d2ad5f6a2d96a904cdd72b9b33
+  metadata.gz: 5cd33c7551f3da873475ca05e7047b40cd83abf4016e97fcdcbf266dca32b9b2
+  data.tar.gz: 4bce7700302da9f025b7bea65102973375746d6f767013a0b4db9259b7aea464
 SHA512:
-  metadata.gz: 0ebc27526e8c259b80a40171e7eb65fa529c477621366296926acbb266f20dd44a55cff96a875cf77cf7c3d739d2d7f252281fec9671a06400829ae01f84883b
-  data.tar.gz: 36e07d94b685e170b815ca07f1e2c8e50b580b02c49602e8737aced082e606b3c269e1173c9ed92dee89d53418f1dc3a04491d0d9510992e4f04088062fca15e
+  metadata.gz: 9914adec792666008ce4a122d9014ede48b27c7c649c26b969d9eddf34e08a742382feda2925991522f0a9d632763d3d65df444ac48ad3ac5927bc0f44750ed7
+  data.tar.gz: 297426eacd2fe788c6fb2f7ea239106a3c4eab1ea48e1506f36058ec259479e49a9c2d7aa746b090fe16f147e46568c6cb101b8351bb70ec3b226ccdbf965069

data/README.md

@@ -17,6 +17,12 @@ hdrcc --get-tuto
 
 __What's new_
 
+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 +3262,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 +3519,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 +3975,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 +4127,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/lib/HDLRuby/hdr_samples/with_henumerable.rb

@@ -0,0 +1,366 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of hardware enumerable capabilities.
+# - The first check is for hall?
+# - The second check is for hany?
+# - The third check is for hchain
+# - The forth check is for hmap
+# - The fifth check is for hmap with with_index
+# - The sixth check is for hcompact
+# - The seventh checks is for hcount
+# - The eighth check is for hcycle
+# - The nineth check is for hfind
+# - The tenth check is for hdrop and hdrop_while
+# - The eleventh check is for heach_cons
+# - The twelveth check is for heach_slice
+# - The thirteenth check is for hto_a
+# - The forteenth check is for hselect
+# - The fifteenth check is for hfind_index
+# - The sixteenth check is for hfirst
+# - The seventeenth check is for hinject
+# - The eighteenth check is for hmax
+# - The nineteenth check is for hmax_by
+# - The twentieth check is for hmax_by
+# - The twenty firth check is for hmin
+# - The twenty second check is for hmin_by
+# - The twenty third check is for hminmax and hminmax_by
+# - The twenty fourth check is for hnone?
+# - The twenty fifth check is for hone?
+# - The twenty sixth check is for hreverse_each
+# - The twenty seventh check is for hsort and hsort_by
+# - The twenty eighth check is for hsum
+# - The twenty nineth check is for htake and htake_while
+# - The thirtieth check is for suniq
+# - The thirty first check is for hzip
+#
+ 
+system :henmerable_checks do
+
+    inner :clk,:rst
+
+    bit[8][-8].inner vals: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44 ]
+    rvals = 8.times.to_a.reverse
+
+    [16].inner :res0, :res1, :res2, :res3
+
+    res0 <= vals.hall? { |val| val != _h11 }
+    res1 <= vals.hall? { |val| val != _h5C }
+
+    par(clk.posedge) do
+      # hprint("#0\n")
+      res2 <= rvals.hall? { |val| val.to_expr != 11 }
+      res3 <= rvals.hall? { |val| val.to_expr != 4 }
+      # hprint("#1 res0=",res0," res1=",res1," res2=",res2," res3=",res3,"\n")
+    end
+
+    [16].inner :res4, :res5, :res6, :res7
+
+    res4 <= vals.hany? { |val| val == _h11 }
+    res5 <= vals.hany? { |val| val == _h5C }
+
+    par(clk.posedge) do
+        # hprint("$0\n")
+        res6 <= rvals.hany? { |val| val == 11 }
+        res7 <= rvals.hany? { |val| val == 4 }
+        # hprint("#1 res4=",res4," res5=",res5," res6=",res6," res7=",res7,"\n")
+    end
+
+    [16].inner :res8, :res9, :res10, :res11
+
+    res8 <= vals.hchain(0..10).hany? { |val| val.as(bit[8]) == _h11 }
+    res9 <= vals.hchain(0..10).hany? { |val| val.as(bit[8]) == _h05 }
+
+    par(clk.posedge) do
+      # hprint("!0\n")
+      res10 <= rvals.hchain(vals).hany? { |val| val.as(bit[8]) == _h11 }
+      res11 <= rvals.hchain(vals).hany? { |val| val.as(bit[8]) == _h04 }
+    end
+
+    bit[8][-8].inner :res12, :res13
+
+    res12 <= vals.hmap { |val| val + 1 }
+
+    par(clk.posedge) do
+      # hprint("%0\n");
+      res13 <= vals.hmap { |val| val + 1 }
+    end
+
+    bit[8][-8].inner :res14, :res15
+
+    res14 <= vals.hmap.with_index { |val,i| val + i }
+
+    par(clk.posedge) do
+      # hprint("&0\n");
+      res15 <= vals.hmap.with_index { |val,i| val + i }
+    end
+
+    bit[8][-8].inner vals2: [ _h00, _h10, _h00, _h0B, _hFE, _h00, _h5C, _h00 ]
+    # bit[8][-8].inner :res16, :res17
+
+    # res16 <= vals2.hcompact
+
+    # sequencer(clk.posedge,rst) do
+    #   # hprint("|0\n");
+    #   res17 <= vals2.hcompact
+    # end
+
+    [8].inner :res18, :res19, :res20
+
+    res18 <= vals2.hcount
+    res19 <= vals2.hcount(_h00)
+
+    par(clk.posedge) do
+      # hprint("(0\n");
+      res20 <= vals2.hcount {|elem| elem > _h10 }
+    end
+
+    # [8].inner :res21, :res22
+
+    # vals.hcycle(2) { |elem| res21 <= elem }
+
+    # par(clk.posedge) do
+    #   # hprint(")0\n")
+    #   vals2.hcycle { |elem| res22 <= elem }
+    # end
+
+    [8].inner :res23, :res24
+
+    res23 <= vals.hfind(proc {-1}) { |elem| elem > _h00 }
+
+    par(clk.posedge) do
+      # hprint("=0\n")
+      res24 <= vals.hfind(proc {-1}) { |elem| elem == _hAA }
+    end
+
+    bit[8][-8].inner :res25 #, :res26
+    
+    res25 <= vals.hdrop(3)
+
+    # par(clk.posedge) do
+    #   # hprint("+0\n")
+    #   res26 <= vals.hdrop_while { |elem| elem < _hAA }
+    # end
+
+    bit[8][-8].inner :res27
+
+    par(clk.posedge) do
+      # hprint("*0\n")
+      vals.heach_cons(3).with_index { |(a,b,c),i| res27[i] <= a+b+c }
+    end
+
+    bit[8][-8].inner :res28
+    
+    par(clk.posedge) do
+      # hprint("/0\n")
+      vals.heach_slice(3).with_index do |(a,b,c),i| 
+        if c then
+          res28[i] <= a+b+c
+        elsif b then
+          res28[i] <= a+b
+        else
+          res28[i] <= a
+        end
+      end
+    end
+
+    bit[32][-4].inner :res29
+    
+    par(clk.posedge) do
+      # hprint("~0\n")
+      res29 <= (_h00000001.._h00000004).heach.hto_a
+    end
+
+    [8].inner :res30, :res31, :res31x
+
+    res30 <= vals.hfind_index(_h0B)
+    
+    par(clk.posedge) do
+      # hprint(">0\n")
+      res31 <= vals.hfind_index { |elem| elem < _hAA }
+      res31x <= vals.hfind_index { |elem| elem == _hAA }
+    end
+
+    bit[8][-4].inner :res32
+    
+    par(clk.posedge) do
+      # hprint("<0\n")
+      res32 <= vals.hfirst(4)
+    end
+
+    inner :res33, :res34
+
+    res33 <= vals.hinclude?(_h0B)
+    
+    par(clk.posedge) do
+      # hprint("!0\n")
+      res34 <= vals.hinclude?(_hAA)
+    end
+
+    [8].inner :res35, :res36
+
+    res35 <= vals.hinject(_h01) { |a,b| a+b }
+
+    par(clk.posedge) do
+      # hprint(":0\n")
+      res36 <= vals.hinject(:+)
+    end
+
+    [8].inner :res37
+    bit[8][-3].inner :res38
+
+    res37 <= vals.hmax
+
+    par(clk.posedge) do
+      # hprint(";0\n")
+      # res38 <= vals.hmax(3)
+      res38 <= vals.hmax(1)
+    end
+
+    [8].inner :res39
+    # bit[8][-3].inner :res40
+    [8].inner :res40
+
+    res39 <= vals.hmax_by {|e| e.to_signed }
+
+    par(clk.posedge) do
+      # hprint(",0\n")
+      # res40 <= vals.hmax_by(3) {|e| e.to_signed }
+      res40 <= vals.hmax_by(1) {|e| e.to_signed }
+    end
+
+    [8].inner :res41
+    bit[8][-3].inner :res42
+
+    res41 <= vals.hmin
+
+    par(clk.posedge) do
+      # hprint(".0\n")
+      # res42 <= vals.hmin(3)
+      res42 <= vals.hmin(1)
+    end
+
+    [8].inner :res43
+    bit[8][-3].inner :res44
+
+    res43 <= vals.hmin_by {|e| e.to_signed }
+
+    par(clk.posedge) do
+      # hprint(":0\n")
+      # res44 <= vals.hmin_by(3) {|e| e.to_signed }
+      res44 <= vals.hmin_by(1) {|e| e.to_signed }
+    end
+
+    [16].inner :res45, :res46
+
+    res45 <= vals.hminmax
+
+    par(clk.posedge) do
+      # hprint("]0\n")
+      res46 <= vals.hminmax_by {|e| e.to_signed }
+    end
+
+    [8].inner :res47, :res48
+
+    res47 <= vals.hnone? { |val| val == _h11 }
+
+    par(clk.posedge) do
+      # hprint("[0\n")
+      res48 <= vals.hnone?(_h5C)
+    end
+
+    [8].inner :res49, :res50, :res51
+
+    res49 <= vals.hone?(_h5C)
+
+    par(clk.posedge) do
+      # hprint("[0\n")
+      res50 <= vals.hone? { |val| val == _h11 }
+      res51 <= vals2.hone? { |val| val == _h00 }
+    end
+
+    bit[8][-6].inner :res52
+
+    par(clk.posedge) do
+        # hprint("_0\n")
+      (5..10).hreverse_each.with_index { |val,i| res52[i] <= val }
+    end
+
+    bit[8][-10].inner :res53X, :res54X
+    bit[8][-8].inner :res53, :res54
+    bit[8][-10].inner valsX: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44, _h01, _h82 ]
+
+    res53  <= vals.hsort
+    res54  <= vals.hsort_by { |val| val.to_signed }
+
+    seq(clk.posedge) do
+      # hprint("@0\n")
+      res53X <= valsX.hsort
+      res54X <= valsX.hsort_by(_h7F) { |val| val.to_signed }
+    end
+
+    [8].inner :res55, :res56
+
+    res55 <= vals.hsum
+
+    par(clk.posedge) do
+      # hprint("`0\n")
+      res56 <= vals.hsum { |val| val & _h0F }
+    end
+
+    bit[8][-3].inner :res57
+    # bit[8][-8].inner :res58
+
+    res57 <= vals.htake(3)
+
+    # par(clk.posedge) do
+    #   # hprint("`0\n")
+    #   res58 <= vals.htake_while { |val| val < _hAA }
+    # end
+
+    bit[8][-8].inner vals3: [ _hFE, _h10, _hA5, _h10, _hFE, _h34, _h5C, _h10 ]
+
+    # bit[8][-8].inner :res59,:res60
+
+    # res59 <= vals3.huniq
+
+    # par(clk.posedge) do
+    #   # hprint("~0\n")
+    #   res60 <= vals.huniq { |val| val & _h0F }
+    # end
+
+    bit[8][-8].inner :res61
+    bit[8][-8].inner :res62
+
+    res61 <= vals.hzip((1..6).to_a.map {|i| i.to_expr.as(bit[8]) })
+
+    par(clk.posedge) do
+      # hprint("}0\n")
+      vals.hzip([_h12]*8).each_with_index { |(a,b),i| res62[i] <= a+b }
+    end
+
+
+
+
+    timed do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        repeat(500) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+end