HDLRuby 2.11.12 → 3.1.0

data/lib/HDLRuby/hdr_samples/with_sequencer_enumerable.rb

@@ -0,0 +1,439 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencer's enumerable capabilities.
+# - The first sequencer checks sall?
+# - The second sequencer checks sany?
+# - The third sequencer checks schain
+# - The forth sequencer checks smap
+# - The fifth sequencer checks smap with with_index
+# - The sixth sequencer checks scompact
+# - The seventh sequencer checks scount
+# - The eighth sequencer checks scycle
+# - The nineth sequencer checks sfind
+# - The tenth sequencer checks sdrop and sdrop_while
+# - The eleventh sequencer checks seach_cons
+# - The twelveth sequencer checks seach_slice
+# - The thirteenth sequencer checks sto_a
+# - The forteenth sequencer checks sselect
+# - The fifteenth sequencer checks sfind_index
+# - The sixteenth sequencer checks sfirst
+# - The seventeenth sequencer checks sinject
+# - The eighteenth sequencer checks smax
+# - The nineteenth sequencer checks smax_by
+# - The twentieth sequencer checks smax_by
+# - The twenty firth sequencer checks smin
+# - The twenty second sequencer checks smin_by
+# - The twenty third sequencer checks sminmax and sminmax_by
+# - The twenty fourth sequencer checks snone?
+# - The twenty fifth sequencer checks sone?
+# - The twenty sixth sequencer checks sreverse_each
+# - The twenty seventh sequencer checks ssort and ssort_by
+# - The twenty eighth sequencer checks ssum
+# - 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
+
+    bit[8][-8].inner vals: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44 ]
+
+    [16].inner :res0, :res1
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [16].inner :res2, :res3
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [16].inner :res4
+
+    sequencer(clk.posedge,rst) do
+        # hprint("!0\n")
+        res4 <= 0
+        vals.schain(0..10).seach do |elem|
+            res4 <= elem
+            # hprint("!1 res4=",res4,"\n")
+        end
+        # hprint("!2 res4=",res4,"\n")
+    end
+
+    [8*8].inner :res5
+
+    sequencer(clk.posedge,rst) do
+        # hprint("%0\n");
+        res5 <= 0
+        res5 <= vals.smap { |val| val + 1 }
+        # hprint("%1 res5=",res5,"\n");
+    end
+
+    [8*8].inner :res6
+
+    sequencer(clk.posedge,rst) do
+        # hprint("&0\n");
+        res6 <= 0
+        res6 <= vals.smap.with_index { |val,i| val + i }
+        # 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");
+        res7 <= 0
+        res7 <= vals2.scompact
+        # hprint("|1 res7=",res7,"\n");
+    end
+
+    [8].inner :res8, :res9, :res10
+
+    sequencer(clk.posedge,rst) do
+        # 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");
+    end
+
+    [8].inner :res11, :res12
+
+    sequencer(clk.posedge,rst) do
+        # hprint(")0\n")
+        res11 <= 0
+        res12 <= 0
+        vals.scycle(2) { |elem| res11 <= elem }
+        # hprint(")1 res11=",res11,"\n")
+        vals2.scycle { |elem| res12 <= elem }
+        # hprint(")2 Should never be here! ... res12=",res12,"\n")
+    end
+
+    [8].inner :res13, :res14
+    
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [8*8].inner :res15, :res16
+    
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [8].inner :res17
+    
+    sequencer(clk.posedge,rst) do
+        # hprint("*0\n")
+        res17 <= 0
+        vals.seach_cons(3) { |a,b,c| res17 <= a+b+c }
+        # hprint("*1 res17=",res17,"\n")
+    end
+
+    [8].inner :res18
+    
+    sequencer(clk.posedge,rst) do
+        # hprint("/0\n")
+        res18 <= 0
+        vals.seach_slice(3) { |a,b,c| res18 <= a+b+c }
+        # hprint("/1 res18=",res18,"\n")
+    end
+
+    [32*4].inner :res19
+    
+    sequencer(clk.posedge,rst) do
+        # hprint("~0\n")
+        res19 <= 0
+        res19 <= (_h00000001.._h00000004).seach.sto_a
+        # hprint("~1 res19=",res19,"\n")
+    end
+
+    [8].inner :res21, :res22
+    
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [4*8].inner :res23
+    
+    sequencer(clk.posedge,rst) do
+        # hprint("<0\n")
+        res23 <= 0
+        res23 <= vals.sfirst(4)
+        # hprint("<1 res23=",res23,"\n")
+    end
+
+    inner :res24, :res25
+    
+    sequencer(clk.posedge,rst) do
+        # hprint("!0\n")
+        res24 <= 0
+        res25 <= 0
+        res24 <= vals.sinclude?(_h0B)
+        res25 <= vals.sinclude?(_hAA)
+        # hprint("!1 res24=",res24," res25=",res25,"\n")
+    end
+
+    [8].inner :res26, :res27
+
+    sequencer(clk.posedge,rst) do
+        # hprint(":0\n")
+        res26 <= 0
+        res27 <= 0
+        res26 <= vals.sinject(_h01) { |a,b| a+b }
+        res27 <= vals.sinject(:+)
+        # hprint(":1 res26=",res26," res27=",res27,"\n")
+    end
+
+    [8].inner :res28
+    [8*3].inner :res29
+
+    sequencer(clk.posedge,rst) do
+        # hprint(";0\n")
+        res28 <= 0
+        res29 <= 0
+        res28 <= vals.smax
+        res29 <= vals.smax(3)
+        # hprint(";1 res28=",res28," res29=",res29,"\n")
+    end
+
+    [8].inner :res30
+    [8*3].inner :res31
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [8].inner :res32
+    [8*3].inner :res33
+
+    sequencer(clk.posedge,rst) do
+        # hprint(".0\n")
+        res32 <= 0
+        res33 <= 0
+        res32 <= vals.smin
+        res33 <= vals.smin(3)
+        # hprint(".1 res32=",res32," res33=",res33,"\n")
+    end
+
+    [8].inner :res34
+    [8*3].inner :res35
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [16].inner :res36, :res37
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [8].inner :res38, :res39
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    [8].inner :res40, :res41, :res42
+
+    sequencer(clk.posedge,rst) do
+        # hprint("[0\n")
+        res40 <= 0
+        res41 <= 0
+        res42 <= 0
+        step
+        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")
+    end
+
+    [8].inner :res43
+
+    sequencer(clk.posedge,rst) do
+        # hprint("_0\n")
+        res43 <= 0
+        step
+        (4..10).sreverse_each { |val| res43 <= val }
+        # 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
+        res44X <= 0
+        res45X <= 0
+        step
+        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")
+        res46 <= 0
+        res47 <= 0
+        step
+        res46 <= vals.ssum
+        res47 <= vals.ssum { |val| val & _h0F }
+        # hprint("`1 res46=",res46," res47=",res47,"\n")
+    end
+
+    [8*3].inner :res48
+    [8*8].inner :res49
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    end
+
+    bit[8][-8].inner vals3: [ _hFE, _h10, _hA5, _h10, _hFE, _h34, _h5C, _h10 ]
+
+    [8*8].inner :res50,:res51
+
+    sequencer(clk.posedge,rst) do
+        # hprint("~0\n")
+        res50 <= 0
+        res51 <= 0
+        step
+        res50 <= vals3.suniq
+        res51 <= vals.suniq { |val| val & _h0F }
+        # hprint("~1 res50=",res50," res51=",res51,"\n")
+    end
+
+    [8*4*2].inner :res52
+    bit[8][-8].inner :res53
+    [3].inner :idx
+
+    sequencer(clk.posedge,rst) do
+        # 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")
+    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_enumerator.rb

@@ -0,0 +1,89 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the creation of sequencers enumerators.
+# - The first sequencer checks enumerators on signals.
+# - The second sequencer checks enumerators on ranges.
+# - The third sequencer checks enumerators on arrays.
+# - The fourth sequencer checks custom enumerators.
+system :my_seqencer do
+
+    inner :clk,:rst
+
+    bit[8][-8].inner vals: [ _h01, _h02, _h03, _h04, _h10, _h20, _h30, _h40 ]
+
+    [8].inner :res0, :res1
+
+    sequencer(clk.posedge,rst) do
+        # hprint("#0\n")
+        res0 <= 0
+        res1 <= 0
+        res0 <= vals.ssum
+        res1 <= res0.ssum(_h00)
+        # hprint("#1 res0=",res0," res1=",res1,"\n")
+    end
+
+    [8].inner :res2, :res3
+
+    sequencer(clk.posedge,rst) do
+        # hprint("$0\n")
+        res2 <= 0
+        res3 <= 0
+        res2 <= (1..5).ssum(_h00)
+        res3 <= (res3..res2).ssum
+        # hprint("$1 res2=",res2," res3=",res3,"\n")
+    end
+
+    [8].inner :res4, :res5
+
+    sequencer(clk.posedge,rst) do
+        # hprint("!0\n")
+        res4 <= 0
+        res5 <= 0
+        res4 <= [_h01,_h02,_h03,_h04].ssum
+        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 ]
+
+    [8].inner :res6, :addr, :data
+
+    data <= mem[addr]
+
+    mem_enum = senumerator(bit[8],8) do |i|
+        addr <= i
+        step
+        data
+    end
+
+    sequencer(clk.posedge,rst) do
+        # hprint("~0\n")
+        res6 <= 0
+        res6 <= mem_enum.ssum
+        # hprint("~1 res6=",res6,"\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(100) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+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

@@ -0,0 +1,120 @@
+require 'std/sequencer_sync.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencers with synchronizarion.
+system :my_seqencer do
+
+    inner :clk,:rst
+
+    [8].inner :res0, :res1
+    [8].shared(x0: _hFF,x1: _hFF)
+
+    arbiter(:arbiter0).(x1)
+
+    par(clk.posedge) do
+        x0.select <= x0.select + 1
+    end
+
+    sequencer(clk.posedge,rst) do
+        sloop do
+            res0 <= x0 * 2
+            res1 <= x1 * 2
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        10.stimes do |i|
+            x0 <= i
+            x1 <= i
+            arbiter0 <= 1
+        end
+        arbiter0 <= 0
+    end
+
+    sequencer(clk.posedge,rst) do
+        10.stimes do |i|
+            x0 <= 10-i
+            x1 <= 10-i
+            arbiter0 <= 1
+            step
+        end
+        arbiter0 <= 0
+    end
+
+    sequencer(clk.posedge,rst) do
+        10.stimes do |i|
+            step
+            arbiter0 <= 1
+            x0 <= 128+i
+            x1 <= 128+i
+            step
+            arbiter0 <= 0
+        end
+    end
+
+
+
+    [8].inner :res2, :res20, :res21, :res22
+    [8].shared x2: _hFF 
+
+    monitor(:monitor0).(x2)
+
+    sequencer(clk.posedge,rst) do
+        sloop do
+            res2 <= x2 * 2
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        x2 <= 0
+        monitor0.lock
+        4.stimes do |i|
+            res20 <= res2
+            x2 <= i + 1
+        end
+        res20 <= res2
+        monitor0.unlock
+    end
+
+    sequencer(clk.posedge,rst) do
+        5.stimes do |i|
+            x2 <= 16 + i
+            monitor0.lock
+            res21 <= res2
+            monitor0.unlock
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        5.stimes do |i|
+            x2 <= 32 + i
+            monitor0.lock
+            res22 <= res2
+            step
+            monitor0.unlock
+        end
+    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(100) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+end