HDLRuby 3.0.0 → 3.2.0

data/lib/HDLRuby/hdr_samples/with_channel_other.rb

@@ -1,6 +1,8 @@
 require 'std/channel.rb'
 require 'std/hruby_unit.rb'
 
+raise "std/channel.rb is deprecated."
+
 include HDLRuby::High::Std
 
 # A clocked handshake channel for testing purpuse.

data/lib/HDLRuby/hdr_samples/with_class.rb

@@ -1,5 +1,7 @@
 # A class for a handshake transmission.
 
+raise "Deprecated code."
+
 class Handshaker
 
     ## Create a new handshaker for transmitting +type+ data.
@@ -179,7 +181,7 @@ end
 
 # A system testing the producer/consumer.
 system :hs_test do
-    input :clk,:rst
+    inner :clk,:rst
 
     # Declares the handshaker
     hs = Handshaker.new([8])

data/lib/HDLRuby/hdr_samples/with_connector.rb

@@ -1,6 +1,8 @@
 require 'std/channel.rb'
 require 'std/connector.rb'
 
+raise "std/channel.rb is deprecated."
+
 include HDLRuby::High::Std
 
 # Sample for testing the connectors of channels.

data/lib/HDLRuby/hdr_samples/with_connector_memory.rb

@@ -3,6 +3,8 @@ require "std/fixpoint.rb"
 require 'std/channel.rb'
 require 'std/connector.rb'
 
+raise "std/channel.rb is deprecated."
+
 include HDLRuby::High::Std
 
 system :channel_connector do

data/lib/HDLRuby/hdr_samples/with_fixpoint.rb

@@ -11,6 +11,12 @@ system :fix_test do
     bit[3..0,3..0].inner :x,:y,:z
     # Declare three 8-bit integer part 8-bit fractional part
     signed[3..0,3..0].inner :a,:b,:c,:d
+    # Declare the comparison results.
+    bit.inner :cmpU, :cmpS
+
+    cmpU <= (x >= y)
+    cmpS <= (a >= b)
+
 
     # Performs calculation between then
     timed do

data/lib/HDLRuby/hdr_samples/with_fixpoint_adv.rb

@@ -0,0 +1,73 @@
+# Sample for testing advanced expressions with fixpoint.
+
+system :with_fixpoint_adv do
+    inner :clk,:rst
+    signed[8,8].inner :x,:y,:z,:u,:v,:w,:a,:b,:c,:d
+    bit.inner :cmp
+
+    cmp <= (x >= y)
+    u   <= (x >= y)
+
+    sequencer(clk,rst) do
+        hif(5>4) { w <= _hFFFF }
+        helse    { w <= _h0000 }
+        swhile(w<_h0000) do
+            hif(5>6) { w <= _hFFFF }
+            helse    { w <= _h0000 }
+        end
+        5.stimes do
+            x <= _h0100
+            y <= _hFF34
+            a <= _h0100
+            b <= _h0100
+            c <= _h0100
+            step
+            x <= x*a
+            hif(x>=y) { z <= _hFFFF }
+            helse     { z <= _h0000 }
+            v <= mux(x>=y,_h0000,_hFFFF)
+            hif(10>0) { w <= _hFFFF }
+            helse     { w <= _h0000 }
+            d <= a*b*c
+            step
+            x <= _h0000
+            x <= x*a
+            y <= _hFE68
+            hif(x>=y) { z <= _hFFFF }
+            helse     { z <= _h0000 }
+            v <= mux(x>=y,_h0000,_hFFFF)
+            hif(1>20) { w <= _hFFFF }
+            helse     { w <= _h0000 }
+            a <= _h0200
+            d <= a*b*c
+            step
+            x <= _hFE00
+            x <= x*a
+            y <= _hFE02
+            hif(x>=y) { z <= _hFFFF }
+            helse     { z <= _h0000 }
+            v <= mux(x>=y,_h0000,_hFFFF)
+            b <= _h0200
+            d <= a*b*c
+        end
+    end
+
+    def cstep(n=1)
+        n.times do
+            clk <= ~clk
+            !10.ns
+        end
+    end
+
+    timed do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        cstep(2)
+        rst <= 1
+        cstep(2)
+        rst <= 0
+        cstep(40)
+    end
+    
+end

data/lib/HDLRuby/hdr_samples/with_leftright.rb

@@ -3,7 +3,7 @@
 system :leftright_bench do
     [8].inner :l,:r0,:r1,:lr
 
-    par do
+    seq do
         lr <= r0*2
         l <= [lr[7],lr[6..0]].to_expr + r1
     end

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

@@ -16,74 +16,75 @@ include HDLRuby::High::Std
 # - One sequencer puts the sum of two arrays in a third one.
 # - One sequencer iterates over two arrays.
 # - One sequencer iterates downward.
+# - One sequencer checks sub iterators (HDLRuby special).
 system :my_seqencer do
 
     inner :clk,:rst
     [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 +94,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 +134,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 +154,28 @@ 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")
+    end
+
+    [8].inner :res7,:res8
+
+    sequencer(clk.posedge,rst) do
+        res7 <= 0
+        res8 <= 0
+        ar0.seach_range(0..3) do |elem|
+            res7 <= elem
+        end
+        ar0.seach_range(4..9) do |elem|
+            res7 <= elem
+        end
+        (_h00.._h07).seach_range(1..4) do |elem|
+            res8 <= elem
         end
-        hprint(")2 res6=",res6,"\n")
     end
 
 

data/lib/HDLRuby/hdr_samples/with_sequencer_channel.rb

@@ -0,0 +1,58 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencers' channels.
+system :my_seqencer do
+
+    inner :clk,:rst,filled: 0
+    bit[16][-16].inner :mem
+    [16].inner :res0, :res1, :res2, :res3
+
+    ch_read = schannel(bit[16],16) do |i|
+        mem[i]
+    end
+
+    ch_write = schannel(bit[16],16) do |i,val|
+        mem[i] <= val
+    end
+
+    sequencer(clk.posedge,rst) do
+        16.stimes { |i| ch_write.snext!(i) }
+        filled <= 1
+        16.stimes do |i| 
+            res0 <= ch_read.snext 
+            res1 <= ch_read[15-i]
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        swhile(~filled);
+        16.stimes do |i| 
+            res2 <= ch_read.snext 
+            res3 <= ch_read[15-i]
+        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