HDLRuby 3.0.0 → 3.1.0

data/lib/HDLRuby/hdr_samples/constant_in_function.rb

@@ -1,7 +1,8 @@
 # Sample for testing constant declaration in function.
 
 
-function :func do |addr|
+# function :func do |addr|
+hdef :func do |addr|
     bit[4][-4].constant tbl: [ _b1000, _b1001, _b1010, _b1011 ]
     
     tbl[addr]

data/lib/HDLRuby/hdr_samples/with_ref_expr.rb

@@ -0,0 +1,30 @@
+
+# A benchmark for testing range reference and index reference on expressions.
+system :with_concat do
+    [8].inner :val0,:val1
+    inner :val2
+    [4].inner :val3, :count
+    inner :val4
+    [4].inner :val5
+
+    val2 <= (val0+val1)[4]
+    val3 <= (val0+val1)[3..0]
+
+    val4 <= val0[4]
+    val5 <= val0[3..0]
+
+    timed do
+        val0 <= _b00001111
+        val1 <= _b11000011
+        count <= 0
+        !10.ns
+        val0 <= _b11110000
+        val1 <= _b00111100
+        count <= 1
+        !10.ns
+        val0 <= _b10101010
+        val1 <= _b01010101
+        count <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_sequencer.rb

@@ -22,68 +22,68 @@ system :my_seqencer do
     [16].inner :u, :v,:res0
 
     sequencer(clk.posedge,rst) do
-        hprint("#0\n")
+        # hprint("#0\n")
         u <= 0
         v <= 1
         step
         res0 <= 0
-        hprint("#1 res0=",res0,"\n")
+        # hprint("#1 res0=",res0,"\n")
         swhile(v < 100) do
             v <= u + v
             u <= v - u
-            hprint("#2 v=",v,"\n")
+            # hprint("#2 v=",v,"\n")
         end
         res0 <= v
-        hprint("#3 res0=",res0,"\n")
+        # hprint("#3 res0=",res0,"\n")
     end
 
     [16].inner :uu, :vv
     sequencer(clk.posedge,rst) do
-        hprint("##0\n")
+        # hprint("##0\n")
         uu <= 0
         vv <= 1
         swhile(vv<10000) do
             vv <= uu + vv
             uu <= vv - uu
             step
-            hprint("##1 vv=",vv,"\n")
+            # hprint("##1 vv=",vv,"\n")
             sif(vv >= 100) { sterminate }
         end
-        hprint("##2 vv=",vv,"... But should not be here!\n")
+        # hprint("##2 vv=",vv,"... But should not be here!\n")
     end
 
     [16].inner :uuu, :vvv, :res00
 
     sequencer(clk.posedge,rst) do
-        hprint("###0\n")
+        # hprint("###0\n")
         res00 <= 0
+        steps(3) # Checks 3 steps
         uuu <= 0
         vvv <= 1
         swhile(vvv<10000) do
             vvv <= uuu + vvv
             uuu <= vvv - uuu
-            step
-            hprint("##1 vvv=",vvv,"\n")
+            # hprint("##1 vvv=",vvv,"\n")
             sif(vvv >= 100) { sbreak }
             selse { res00 <= res00 + 1 }
         end
-        hprint("##2 res00=",res00,"... and should be here!\n")
+        # hprint("##2 res00=",res00,"... and should be here!\n")
     end
 
     [8].inner :a,:b
 
     sequencer(clk.posedge,rst) do
-        hprint("=0\n")
+        # hprint("=0\n")
         a <= 0
         b <= 0
         sfor(0..19) do
             a <= a + 1
-            hprint("=1 a=",a,"\n")
+            # hprint("=1 a=",a,"\n")
             sif(a % 4) { scontinue }
             b <= b + 1
-            hprint("=2 b=",b,"\n")
+            # hprint("=2 b=",b,"\n")
         end
-        hprint("=3 a=",a," b=",b,"\n")
+        # hprint("=3 a=",a," b=",b,"\n")
     end
 
 
@@ -93,41 +93,36 @@ system :my_seqencer do
 
     sequencer(clk.posedge,rst) do
         res1 <= 0
-        hprint("$0 res1=",res1,"\n")
-        # sfor(buf) do |elem,idx|
-        # buf.seach.with_index do |elem,idx|
-        #     res1 <= elem * elem
-        #     hprint("$1 res1=",res1," idx=",idx,"\n")
-        # end
+        # hprint("$0 res1=",res1,"\n")
         buf.seach do |elem|
             res1 <= elem * elem
-            hprint("$1 elem=",elem," res1=",res1,"\n")
+            # hprint("$1 elem=",elem," res1=",res1,"\n")
         end
-        hprint("$2 res1=",res1,"\n")
+        # hprint("$2 res1=",res1,"\n")
     end
 
     [32].inner :res2
 
     sequencer(clk.posedge,rst) do
         res2 <= 0
-        hprint("%0 res2=",res2,"\n")
-        (0..7).seach do |elem|
+        # hprint("%0 res2=",res2,"\n")
+        (_h00000000.._h00000007).seach do |elem|
             res2 <= elem * elem
-            hprint("%1 elem=",elem," res2=",res2,"\n")
+            # hprint("%1 elem=",elem," res2=",res2,"\n")
         end
-        hprint("%2 res2=",res2,"\n")
+        # hprint("%2 res2=",res2,"\n")
     end
 
     [32].inner :res3
 
     sequencer(clk.posedge,rst) do
         res3 <= 0
-        hprint("&0 res3=",res3,"\n")
+        # hprint("&0 res3=",res3,"\n")
         5.supto(10).with_index do |elem,idx|
             res3 <= [elem[15..0],idx[15..0]]
-            hprint("&1 elem=",elem," idx=",idx," res3=",res3,"\n")
+            # hprint("&1 elem=",elem," idx=",idx," res3=",res3,"\n")
         end
-        hprint("&2 res3=",res3,"\n")
+        # hprint("&2 res3=",res3,"\n")
     end
 
     bit[8][-8].inner ar0: [_h01,_h02,_h04,_h08, _h10,_h20,_h40,_h80]
@@ -138,19 +133,19 @@ system :my_seqencer do
         sfor(ar0) do |elem,idx|
             res4[idx] <= elem + ar1[idx]
         end
-        hprint("res4=",res4,"\n")
+        # hprint("res4=",res4,"\n")
     end
 
     [8].inner :res5
 
     sequencer(clk.posedge,rst) do
         res5 <= 0
-        hprint("(0 res5=",res5,"\n")
+        # hprint("(0 res5=",res5,"\n")
         (ar0.seach + ar1).seach do |elem|
             res5 <= elem
-            hprint("(1 res5=",res5,"\n")
+            # hprint("(1 res5=",res5,"\n")
         end
-        hprint("(2 res5=",res5,"\n")
+        # hprint("(2 res5=",res5,"\n")
     end
 
 
@@ -158,12 +153,12 @@ system :my_seqencer do
 
     sequencer(clk.posedge,rst) do
         res6 <= 0
-        hprint(")0 res6=",res6,"\n")
+        # hprint(")0 res6=",res6,"\n")
         10.sdownto(1) do |elem|
             res6 <= elem
-            hprint(")1 res6=",res6,"\n")
+            # hprint(")1 res6=",res6,"\n")
         end
-        hprint(")2 res6=",res6,"\n")
+        # hprint(")2 res6=",res6,"\n")
     end
 
 

data/lib/HDLRuby/hdr_samples/with_sequencer_enumerable.rb

@@ -34,6 +34,34 @@ include HDLRuby::High::Std
 # - The twenty nineth sequencer checks stake and stake_while
 # - The thirtieth sequencer checks suniq
 # - The thirty first sequencer checks szip
+#
+# __WARNING__: All the operations on enumerators generate their own result
+#              signal. Therefore, in a real circuit, there is no need to
+#              declare your own signal for it, as demonstrated in this sample. 
+#              In other words, the res<num> signals are unnecessary, and 
+#              assigning the result to them only slows down the circuit without 
+#              any benefit. Instead, they can be replaced with Ruby variables
+#              as shown below:
+#                 from: res<num> <= <enumerator operation> 
+#                 to:   <ruby variable> = <enumerator operation>
+#              In this sample it is done this way for an easy vizualization of
+#              the multiple results.
+#              
+#              For instance the first example should be rewritten from:
+#                 [16].inner :res0, :res1
+#                 sequencer(clk.posedge,rst) do
+#                    res0 <= 0; res1 <= 1
+#                    step
+#                    res0 <= vals.sall? { |val| val!= _h11 }
+#                    res1 <= vals.sall? { |val| val!= _h5C }
+#                 end
+#              to:
+#                 res0 = nil; res1 = nil
+#                 sequencer(clk.posedge,rst) do
+#                    res0 = vals.sall? { |val| val!= _h11 }
+#                    res1 = vals.sall? { |val| val!= _h5C }
+#                 end
+#
 system :my_seqencer do
 
     inner :clk,:rst
@@ -43,258 +71,258 @@ system :my_seqencer do
     [16].inner :res0, :res1
 
     sequencer(clk.posedge,rst) do
-        hprint("#0\n")
+        # hprint("#0\n")
         res0 <= 0
         res1 <= 0
         step
         res0 <= vals.sall? { |val| val != _h11 }
         res1 <= vals.sall? { |val| val != _h5C }
-        hprint("#1 res0=",res0," res1=",res1,"\n")
+        # hprint("#1 res0=",res0," res1=",res1,"\n")
     end
 
     [16].inner :res2, :res3
 
     sequencer(clk.posedge,rst) do
-        hprint("$0\n")
+        # hprint("$0\n")
         res2 <= 0
         res3 <= 0
         step
         res2 <= vals.sany? { |val| val == _h11 }
         res3 <= vals.sany? { |val| val == _h5C }
-        hprint("$1 res2=",res2," res3=",res3,"\n")
+        # hprint("$1 res2=",res2," res3=",res3,"\n")
     end
 
     [16].inner :res4
 
     sequencer(clk.posedge,rst) do
-        hprint("!0\n")
+        # hprint("!0\n")
         res4 <= 0
         vals.schain(0..10).seach do |elem|
             res4 <= elem
-            hprint("!1 res4=",res4,"\n")
+            # hprint("!1 res4=",res4,"\n")
         end
-        hprint("!2 res4=",res4,"\n")
+        # hprint("!2 res4=",res4,"\n")
     end
 
     [8*8].inner :res5
 
     sequencer(clk.posedge,rst) do
-        hprint("%0\n");
+        # hprint("%0\n");
         res5 <= 0
         res5 <= vals.smap { |val| val + 1 }
-        hprint("%1 res5=",res5,"\n");
+        # hprint("%1 res5=",res5,"\n");
     end
 
     [8*8].inner :res6
 
     sequencer(clk.posedge,rst) do
-        hprint("&0\n");
+        # hprint("&0\n");
         res6 <= 0
         res6 <= vals.smap.with_index { |val,i| val + i }
-        hprint("&1 res6=",res6,"\n");
+        # hprint("&1 res6=",res6,"\n");
     end
 
     bit[8][-8].inner vals2: [ _h00, _h10, _h00, _h0B, _hFE, _h00, _h5C, _h00 ]
     [8*8].inner :res7
 
     sequencer(clk.posedge,rst) do
-        hprint("|0\n");
+        # hprint("|0\n");
         res7 <= 0
         res7 <= vals2.scompact
-        hprint("|1 res7=",res7,"\n");
+        # hprint("|1 res7=",res7,"\n");
     end
 
     [8].inner :res8, :res9, :res10
 
     sequencer(clk.posedge,rst) do
-        hprint("(0\n");
+        # hprint("(0\n");
         res8 <= 0
         res9 <= 0
         res10 <= 0
         res8 <= vals2.scount
         res9 <= vals2.scount(_h00)
         res10 <= vals2.scount {|elem| elem > _h10 }
-        hprint("(1 res8=",res8," res9=",res9," res10=",res10,"\n");
+        # hprint("(1 res8=",res8," res9=",res9," res10=",res10,"\n");
     end
 
     [8].inner :res11, :res12
 
     sequencer(clk.posedge,rst) do
-        hprint(")0\n")
+        # hprint(")0\n")
         res11 <= 0
         res12 <= 0
         vals.scycle(2) { |elem| res11 <= elem }
-        hprint(")1 res11=",res11,"\n")
+        # hprint(")1 res11=",res11,"\n")
         vals2.scycle { |elem| res12 <= elem }
-        hprint(")2 Should never be here! ... res12=",res12,"\n")
+        # hprint(")2 Should never be here! ... res12=",res12,"\n")
     end
 
     [8].inner :res13, :res14
     
     sequencer(clk.posedge,rst) do
-        hprint("=0\n")
+        # hprint("=0\n")
         res13 <= 0
         res14 <= 0
         res13 <= vals.sfind(-1) { |elem| elem > 0 }
         res14 <= vals.sfind(-1) { |elem| elem == _hAA }
-        hprint("=1 res13=",res13," res14=",res14,"\n")
+        # hprint("=1 res13=",res13," res14=",res14,"\n")
     end
 
     [8*8].inner :res15, :res16
     
     sequencer(clk.posedge,rst) do
-        hprint("+0\n")
+        # hprint("+0\n")
         res15 <= 0
         res16 <= 0
         res15 <= vals.sdrop(3)
         res16 <= vals.sdrop_while { |elem| elem < _hAA }
-        hprint("+1 res15=",res15," res16=",res16,"\n")
+        # hprint("+1 res15=",res15," res16=",res16,"\n")
     end
 
     [8].inner :res17
     
     sequencer(clk.posedge,rst) do
-        hprint("*0\n")
+        # hprint("*0\n")
         res17 <= 0
         vals.seach_cons(3) { |a,b,c| res17 <= a+b+c }
-        hprint("*1 res17=",res17,"\n")
+        # hprint("*1 res17=",res17,"\n")
     end
 
     [8].inner :res18
     
     sequencer(clk.posedge,rst) do
-        hprint("/0\n")
+        # hprint("/0\n")
         res18 <= 0
         vals.seach_slice(3) { |a,b,c| res18 <= a+b+c }
-        hprint("/1 res18=",res18,"\n")
+        # hprint("/1 res18=",res18,"\n")
     end
 
     [32*4].inner :res19
     
     sequencer(clk.posedge,rst) do
-        hprint("~0\n")
+        # hprint("~0\n")
         res19 <= 0
-        res19 <= (1..4).seach.sto_a
-        hprint("~1 res19=",res19,"\n")
+        res19 <= (_h00000001.._h00000004).seach.sto_a
+        # hprint("~1 res19=",res19,"\n")
     end
 
     [8].inner :res21, :res22
     
     sequencer(clk.posedge,rst) do
-        hprint(">0\n")
+        # hprint(">0\n")
         res21 <= 0
         res22 <= 0
         res21 <= vals.sfind_index(_h0B)
         res22 <= vals.sfind_index { |elem| elem < _hAA }
-        hprint(">1 res21=",res21," res22=",res22,"\n")
+        # hprint(">1 res21=",res21," res22=",res22,"\n")
     end
 
     [4*8].inner :res23
     
     sequencer(clk.posedge,rst) do
-        hprint("<0\n")
+        # hprint("<0\n")
         res23 <= 0
         res23 <= vals.sfirst(4)
-        hprint("<1 res23=",res23,"\n")
+        # hprint("<1 res23=",res23,"\n")
     end
 
     inner :res24, :res25
     
     sequencer(clk.posedge,rst) do
-        hprint("!0\n")
+        # hprint("!0\n")
         res24 <= 0
         res25 <= 0
         res24 <= vals.sinclude?(_h0B)
         res25 <= vals.sinclude?(_hAA)
-        hprint("!1 res24=",res24," res25=",res25,"\n")
+        # hprint("!1 res24=",res24," res25=",res25,"\n")
     end
 
     [8].inner :res26, :res27
 
     sequencer(clk.posedge,rst) do
-        hprint(":0\n")
+        # hprint(":0\n")
         res26 <= 0
         res27 <= 0
-        res26 <= vals.sinject(1) { |a,b| a+b }
+        res26 <= vals.sinject(_h01) { |a,b| a+b }
         res27 <= vals.sinject(:+)
-        hprint(":1 res26=",res26," res27=",res27,"\n")
+        # hprint(":1 res26=",res26," res27=",res27,"\n")
     end
 
     [8].inner :res28
     [8*3].inner :res29
 
     sequencer(clk.posedge,rst) do
-        hprint(";0\n")
+        # hprint(";0\n")
         res28 <= 0
         res29 <= 0
         res28 <= vals.smax
         res29 <= vals.smax(3)
-        hprint(";1 res28=",res28," res29=",res29,"\n")
+        # hprint(";1 res28=",res28," res29=",res29,"\n")
     end
 
     [8].inner :res30
     [8*3].inner :res31
 
     sequencer(clk.posedge,rst) do
-        hprint(",0\n")
+        # hprint(",0\n")
         res30 <= 0
         res31 <= 0
         res30 <= vals.smax_by {|e| e.to_signed }
         res31 <= vals.smax_by(3) {|e| e.to_signed }
-        hprint(",1 res30=",res30," res31=",res31,"\n")
+        # hprint(",1 res30=",res30," res31=",res31,"\n")
     end
 
     [8].inner :res32
     [8*3].inner :res33
 
     sequencer(clk.posedge,rst) do
-        hprint(".0\n")
+        # hprint(".0\n")
         res32 <= 0
         res33 <= 0
         res32 <= vals.smin
         res33 <= vals.smin(3)
-        hprint(".1 res32=",res32," res33=",res33,"\n")
+        # hprint(".1 res32=",res32," res33=",res33,"\n")
     end
 
     [8].inner :res34
     [8*3].inner :res35
 
     sequencer(clk.posedge,rst) do
-        hprint(":0\n")
+        # hprint(":0\n")
         res34 <= 0
         res35 <= 0
         res34 <= vals.smin_by {|e| e.to_signed }
         res35 <= vals.smin_by(3) {|e| e.to_signed }
-        hprint(":1 res34=",res34," res35=",res35,"\n")
+        # hprint(":1 res34=",res34," res35=",res35,"\n")
     end
 
     [16].inner :res36, :res37
 
     sequencer(clk.posedge,rst) do
-        hprint("]0\n")
+        # hprint("]0\n")
         res36 <= 0
         res37 <= 0
         res36 <= vals.sminmax
         res37 <= vals.sminmax_by {|e| e.to_signed }
-        hprint("]1 res36=",res36," res37=",res37,"\n")
+        # hprint("]1 res36=",res36," res37=",res37,"\n")
     end
 
     [8].inner :res38, :res39
 
     sequencer(clk.posedge,rst) do
-        hprint("[0\n")
+        # hprint("[0\n")
         res38 <= 0
         res39 <= 0
         step
         res38 <= vals.snone? { |val| val == _h11 }
         res39 <= vals.snone?(_h5C)
-        hprint("[1 res38=",res38," res39=",res39,"\n")
+        # hprint("[1 res38=",res38," res39=",res39,"\n")
     end
 
     [8].inner :res40, :res41, :res42
 
     sequencer(clk.posedge,rst) do
-        hprint("[0\n")
+        # hprint("[0\n")
         res40 <= 0
         res41 <= 0
         res42 <= 0
@@ -302,54 +330,60 @@ system :my_seqencer do
         res40 <= vals.sone?(_h5C)
         res41 <= vals.sone? { |val| val == _h11 }
         res42 <= vals2.sone? { |val| val == _h00 }
-        hprint("[1 res40=",res40," res41=",res41," res42=",res42,"\n")
+        # hprint("[1 res40=",res40," res41=",res41," res42=",res42,"\n")
     end
 
     [8].inner :res43
 
     sequencer(clk.posedge,rst) do
-        hprint("_0\n")
+        # hprint("_0\n")
         res43 <= 0
         step
         (4..10).sreverse_each { |val| res43 <= val }
-        hprint("_1 res43=",res43,"\n")
+        # hprint("_1 res43=",res43,"\n")
     end
 
+    [8*10].inner :res44X, :res45X
     [8*8].inner :res44, :res45
+    bit[8][-10].inner valsX: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44, _h01, _h82 ]
 
     sequencer(clk.posedge,rst) do
-        hprint("@0\n")
-        res44 <= 0
-        res45 <= 0
+        # hprint("@0\n")
+        res44  <= 0
+        res45  <= 0
+        res44X <= 0
+        res45X <= 0
         step
-        res44 <= vals.ssort
-        res45 <= vals.ssort_by { |val| val.to_signed }
-        hprint("@1 res44=",res44," res45=",res45,"\n")
+        res44  <= vals.ssort
+        res45  <= vals.ssort_by { |val| val.to_signed }
+        res44X <= valsX.ssort
+        res45X <= valsX.ssort_by { |val| val.to_signed }
+        # hprint("@1 res44=",res44," res45=",res45,"\n")
     end
 
     [8].inner :res46, :res47
 
     sequencer(clk.posedge,rst) do
-        hprint("`0\n")
+        # hprint("`0\n")
         res46 <= 0
         res47 <= 0
         step
         res46 <= vals.ssum
         res47 <= vals.ssum { |val| val & _h0F }
-        hprint("`1 res46=",res46," res47=",res47,"\n")
+        # hprint("`1 res46=",res46," res47=",res47,"\n")
     end
 
     [8*3].inner :res48
     [8*8].inner :res49
 
     sequencer(clk.posedge,rst) do
-        hprint("`0\n")
+        # hprint("`0\n")
         res48 <= 0
         res49 <= 0
         step
         res48 <= vals.stake(3)
         res49 <= vals.stake_while { |val| val < _hAA }
-        hprint("`1 res48=",res48," res49=",res49,"\n")
+        # hprint("`1 res48=",res48," res49=",res49,"\n")
     end
 
     bit[8][-8].inner vals3: [ _hFE, _h10, _hA5, _h10, _hFE, _h34, _h5C, _h10 ]
@@ -357,13 +391,13 @@ system :my_seqencer do
     [8*8].inner :res50,:res51
 
     sequencer(clk.posedge,rst) do
-        hprint("\"0\n")
+        # hprint("~0\n")
         res50 <= 0
         res51 <= 0
         step
         res50 <= vals3.suniq
         res51 <= vals.suniq { |val| val & _h0F }
-        hprint("\"1 res50=",res50," res51=",res51,"\n")
+        # hprint("~1 res50=",res50," res51=",res51,"\n")
     end
 
     [8*4*2].inner :res52
@@ -371,13 +405,13 @@ system :my_seqencer do
     [3].inner :idx
 
     sequencer(clk.posedge,rst) do
-        hprint("}0\n")
+        # hprint("}0\n")
         res52 <= 0
         idx   <= 0
         step
         res52 <= vals.szip((1..6).to_a.map {|i| i.to_expr.as(bit[8]) })
         vals.szip([_h12]*8) { |a,b| res53[idx] <= a+b; idx <= idx + 1 }
-        hprint("}1 res52=",res52," res53=",res53,"\n")
+        # hprint("}1 res52=",res52," res53=",res53,"\n")
     end
 
 
@@ -397,7 +431,7 @@ system :my_seqencer do
         rst <= 0
         !10.ns
         clk <= 1
-        repeat(100) do
+        repeat(500) do
             !10.ns
             clk <= ~clk
         end