HDLRuby 3.0.0 → 3.2.0

data/lib/HDLRuby/hdr_samples/with_sequencer_enumerable.rb

@@ -34,6 +34,35 @@ include HDLRuby::High::Std
 # - The twenty nineth sequencer checks stake and stake_while
 # - The thirtieth sequencer checks suniq
 # - The thirty first sequencer checks szip
+# - The thirty second sequnecer checks seach_nexts (HDLRuby special)
+#
+# __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 +72,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 +331,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 +392,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 +406,22 @@ 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
+
+    [8].inner :res54,:res55
+
+    sequencer(clk.posedge,rst) do
+        res54 <= 0
+        res55 <= 0
+        vals.seach_nexts(6) { |i| res54 <= i }
+        res55 <= vals.seach_nexts(4).ssum
     end
 
 
@@ -397,7 +441,7 @@ system :my_seqencer do
         rst <= 0
         !10.ns
         clk <= 1
-        repeat(100) do
+        repeat(500) do
             !10.ns
             clk <= ~clk
         end

data/lib/HDLRuby/hdr_samples/with_sequencer_enumerator.rb

@@ -16,34 +16,34 @@ system :my_seqencer do
     [8].inner :res0, :res1
 
     sequencer(clk.posedge,rst) do
-        hprint("#0\n")
+        # hprint("#0\n")
         res0 <= 0
         res1 <= 0
         res0 <= vals.ssum
         res1 <= res0.ssum(_h00)
-        hprint("#1 res0=",res0," res1=",res1,"\n")
+        # hprint("#1 res0=",res0," res1=",res1,"\n")
     end
 
     [8].inner :res2, :res3
 
     sequencer(clk.posedge,rst) do
-        hprint("$0\n")
+        # hprint("$0\n")
         res2 <= 0
         res3 <= 0
-        res2 <= (1..5).sum
+        res2 <= (1..5).ssum(_h00)
         res3 <= (res3..res2).ssum
-        hprint("$1 res2=",res2," res3=",res3,"\n")
+        # hprint("$1 res2=",res2," res3=",res3,"\n")
     end
 
     [8].inner :res4, :res5
 
     sequencer(clk.posedge,rst) do
-        hprint("!0\n")
+        # hprint("!0\n")
         res4 <= 0
         res5 <= 0
         res4 <= [_h01,_h02,_h03,_h04].ssum
-        res5 <= [1,2,3,4,5].ssum
-        hprint("!1 res4=",res4," res5=",res5,"\n")
+        res5 <= [1,2,3,4,5].ssum(_h00)
+        # hprint("!1 res4=",res4," res5=",res5,"\n")
     end
 
     bit[8][-8].inner mem: [ _h01, _h02, _h03, _h04, _h30, _h30, _h30, _h30 ]
@@ -52,17 +52,31 @@ system :my_seqencer do
 
     data <= mem[addr]
 
-    mem_enum = senumerator(bit[8],8) do |i|
-        addr <= i
-        step
-        data
+    mem_enum = senumerator(bit[8],8) do |i,val|
+        if val then
+            # Write
+            mem[i] <= val
+            step
+            val
+        else 
+            # Read
+            addr <= i
+            step
+            data
+        end
     end
 
     sequencer(clk.posedge,rst) do
-        hprint("~0\n")
+        # hprint("~0\n")
         res6 <= 0
         res6 <= mem_enum.ssum
-        hprint("~1 res6=",res6,"\n")
+        mem_enum.srewind
+        mem_enum.snext!(_hAA)
+        mem_enum.snext!(_hBB)
+        mem_enum.srewind
+        res6 <= mem_enum.snext
+        res6 <= mem_enum.snext
+        # hprint("~1 res6=",res6,"\n")
     end
 
 

data/lib/HDLRuby/hdr_samples/with_sequencer_func.rb

@@ -0,0 +1,63 @@
+require 'std/sequencer_func.rb'
+
+include HDLRuby::High::Std
+
+
+# A factorial with default stack depth.
+sdef(:fact) do |n|
+    hprint("n=",n,"\n")
+    sif(n > 1) { sreturn(n*fact(n-1,20)) } #Recurse setting the stack depth to 20
+    selse      { sreturn(1) }
+end
+
+# A factiorial with very low stack depth for checking overflow.
+sdef(:fact_over,2,proc { stack_overflow_error <= 1 }) do |n|
+    hprint("n2=",n,"\n")
+    sif(n > 1) { sreturn(n*fact_over(n-1)) }
+    selse      { sreturn(1) }
+end
+
+# Checking the usage of sequencers functions.
+system :my_seqencer do
+
+    inner :clk,:rst
+
+    [16].inner :val
+    [16].inner :res
+
+    inner stack_overflow_error: 0
+
+    sequencer(clk.posedge,rst) do
+        5.stimes do |i|
+            val <= i
+            res <= fact(val)
+        end
+        hprint("Going to overflow...\n")
+        4.stimes do |i|
+            val <= i
+            res <= fact_over(val)
+        end
+        hprint("stack_overflow_error=",stack_overflow_error,"\n")
+    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

data/lib/HDLRuby/hdr_samples/with_sequencer_sync.rb

@@ -13,7 +13,8 @@ system :my_seqencer do
     arbiter(:arbiter0).(x1)
 
     par(clk.posedge) do
-        x0.select <= x0.select + 1
+        hif(rst) { x0.select(0) }
+        helse { x0.select(x0.select + 1) }
     end
 
     sequencer(clk.posedge,rst) do